CF

Data Structures & Algorithms: Part 1

4h 39m 17s
English
Paid

Data Structures & Algorithms: Part 1 is a 88-lesson 4 hours 39 minutes self-paced course by Mosh Hamedani (Code with Mosh). Studied Computer Science - but never really understood the complex topic of data structures and algorithms?

Course facts

Lessons
88
Duration
4 hours 39 minutes
Level
All levels
Language
English
Updated
Instructor
Mosh Hamedani (Code with Mosh)
Price
Premium

Studied Computer Science - but never really understood the complex topic of data structures and algorithms? Or maybe you’re a self-taught programmer, with little to no knowledge of this important topic. Or perhaps you failed a job interview because you couldn't answer basic data structure and algorithm questions. Data structures and algorithms are patterns for solving problems. Developers who know more about data structures and algorithms are better at solving problems.

That’s why companies like Google, Microsoft and Amazon, always include interview questions on data structures and algorithms. They want to assess your problem-solving skills. They don't care how many programming languages and frameworks you're familiar with

Who teaches Data Structures & Algorithms: Part 1? Mosh Hamedani (Code with Mosh)

Mosh Hamedani (Code with Mosh) thumbnail

Mosh Hamedani is the founder of Code with Mosh, one of the highest-volume independent online instructors in software education. He has been publishing courses continuously since the early Udemy era and has taught over a million students across his Udemy catalog and his standalone Code with Mosh platform. His teaching style is patient, rigorously structured, and deliberately beginner-tolerant — the courses are widely cited as some of the most accessible introductions to their respective topics.

The Code with Mosh catalog covers an unusually wide span: web development with HTML / CSS / JavaScript / React / Angular / Node.js, Python and Django, C# and .NET, mobile development with React Native and Flutter, SQL and database fundamentals, and the algorithm / data-structure interview prep tracks. Few independent instructors maintain this much breadth at consistent quality.

The CourseFlix listing under this source carries over 35 Code with Mosh courses spanning that range. Material is paid; Code with Mosh runs on per-course pricing on the original platform. Courses are aimed primarily at developers picking up a new technology from a clean start through to working production proficiency.

What lessons are included in Data Structures & Algorithms: Part 1?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 88 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Course Outline
All Course Lessons (88)
#Lesson TitleDurationAccess
1
Course Outline Demo
02:53
2
Introduction
00:25
3
What is Big O
01:59
4
O(1)
01:30
5
O(n)
03:45
6
O(n^2)
02:25
7
O(log n)
02:40
8
O(2^n)
00:51
9
Space Complexity
02:33
10
Introduction
00:45
11
Understanding Arrays
03:09
12
Working with Arrays in Java
03:30
13
Exercise- Array Class
02:52
14
Solution- Creating the Class
03:20
15
Solution- insert()
04:20
16
Solution- removeAt()
04:52
17
Solution- indexOf()
02:29
18
Dynamic Arrays
03:49
19
Summary
01:10
20
Introduction
00:37
21
What are Linked Lists
04:34
22
Working with Linked Lists
03:25
23
Exercise- Building a Linked List
01:26
24
Solution- addLast
06:10
25
Solution- addFirst
02:14
26
Solution- indexOf
01:55
27
Solution- contains
01:06
28
Solution- removeFirst
04:24
29
Solution- removeLast
04:41
30
Implementing size()
04:16
31
Converting Linked Lists to Arrays
02:11
32
Cheat Sheets
01:13
33
Arrays vs Linked Lists
03:22
34
Types of Linked Lists
03:15
35
Exercise- Reversing a Linked List
01:34
36
Solution- Reversing a Linked List
09:01
37
Exercise- Kth Node from the End
03:21
38
Solution- Kth Node from the End
05:23
39
Summary
01:13
40
Introduction
00:32
41
What are Stacks
02:48
42
Working with Stacks
02:22
43
Exercise- Reversing a String
00:42
44
Solution - Reversing a String
05:02
45
Exercise- Balanced Expressions
02:55
46
Solution- A Basic Implementation
05:18
47
Solution- Supporting Other Brackets
03:37
48
Solution- First Refactoring
04:10
49
Solution- Second Refactoring
05:51
50
Exercise- Building a Stack Using an Array
00:48
51
Solution- Implementing a Stack Using an Array
08:19
52
Summary
00:34
53
Introduction
00:27
54
What are Queues
02:05
55
Queues in Java
05:13
56
Exercise- Reversing a Queue
01:07
57
Solution- Reversing a Queue
02:18
58
Exercise- Building a Queue Using an Array
02:04
59
Solution- A Basic Implementation
06:33
60
Solution- Circular Arrays
05:55
61
Exercise- Implementing a Queue Using a Stack
00:56
62
Solution- Building a Queue Using a Stack
07:44
63
Priority Queues
01:54
64
Exercise- Building a Priority Queue
03:58
65
Solution- Building a Priority Queue
08:52
66
Solution- Refactoring
03:03
67
Summary
00:58
68
Introduction
00:27
69
What are Hash Tables
02:45
70
Working with Hash Tables
06:07
71
Exercise- Find the First Non-repeated Character
00:55
72
Solution- First Non-repeating Character
07:40
73
Sets
02:24
74
Exercise- First Repeated Character
00:33
75
Solution- First Repeated Character
02:37
76
Hash Functions
05:56
77
Collisions
01:07
78
Chaining
01:41
79
Open Addressing- Linear Probing
02:42
80
Open Addressing- Quadratic Probing
01:30
81
Open Addressing- Double Hashing
03:20
82
Exercise- Build a HashTable
02:37
83
Solution- put()
06:08
84
Solution- get()
04:30
85
Solution- remove()
02:31
86
Solution- Refactoring
11:05
87
Summary
01:26
88
Course Wrap Up
00:33
Unlock unlimited learning

Get instant access to all 87 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Data Structures & Algorithms: Part 1?

More courses by Mosh Hamedani (Code with Mosh)

Frequently asked questions

What prerequisites do I need before enrolling in this course?
This course is designed for students who have some background in programming, whether through formal education or self-teaching. A basic understanding of programming concepts will be helpful, as the course dives into data structures and algorithms, which are essential patterns for problem-solving in software development.
What projects or exercises will I build throughout the course?
The course includes several hands-on exercises and projects. You will work on building a custom Array class, develop a Linked List, and implement functionality like reversing a string with a stack. These exercises are designed to deepen your understanding of data structures and algorithms by applying concepts in practical scenarios.
Who is the target audience for this course?
This course is aimed at both formally educated computer science students and self-taught programmers who want to strengthen their understanding of data structures and algorithms. It's also suitable for developers preparing for job interviews, as it covers fundamental concepts often tested during technical interviews.
How does this course compare in depth and scope to similar courses?
This course provides 88 lessons focused on foundational topics like Big O notation, arrays, linked lists, stacks, and queues. It offers a balance between theoretical explanations and practical exercises, which may be more comprehensive than courses that focus solely on theory or application. The course is suitable for those seeking a well-rounded understanding of these essential concepts.
What specific tools or languages will I be using in this course?
The course uses Java for implementing data structures such as arrays, linked lists, stacks, and queues. Familiarity with Java will be beneficial, but the primary focus is on understanding the underlying concepts of data structures and algorithms, which can be applied across different programming languages.
What topics are not covered in this course?
This course does not cover advanced data structures and algorithms such as trees, graphs, or sorting algorithms in detail. The focus is on foundational concepts like Big O notation, arrays, linked lists, stacks, and queues, making it the first part of a likely multi-part series on data structures and algorithms.
How much time should I expect to commit to this course?
The course comprises 88 lessons. While the total runtime is not specified, students should anticipate dedicating several weeks to fully engage with the material, complete exercises, and reinforce learning through practice. The time commitment will vary based on individual learning pace and prior experience.