CF

JavaScript Algorithms and Data Structures Masterclass

21h 47m 46s
English
Paid

JavaScript Algorithms and Data Structures Masterclass is a 217-lesson 21 hours 47 minutes self-paced course by Udemy. This course crams months of computer science and interview prep material into 20 hours of video.

Course facts

Lessons
217
Duration
21 hours 47 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

This course crams months of computer science and interview prep material into 20 hours of video. The content is based directly on last semester of my in-person coding bootcamps, where my students go on to land 6-figure developer jobs. I cover the exact same computer science content that has helped my students ace interviews at huge companies like Google, Tesla, Amazon, and Facebook. Nothing is watered down for an online audience; this is the real deal :)   We start with the basics and then eventually cover “advanced topics” that similar courses shy away from like Heaps, Graphs, and Dijkstra’s Shortest Path Algorithm.

I start by teaching you how to analyze your code’s time and space complexity using Big O notation.  We cover the ins and outs of Recursion.  We learn a 5-step approach to solving any difficult coding problem. We cover common programming patterns. We implement popular searching algorithms. We write 6 different sorting algorithms: Bubble, Selection, Insertion, Quick, Merge, and Radix Sort.   Then, we switch gears and implement our own data structures from scratch, including linked lists, trees, heaps, hash tables, and graphs.  We learn to traverse trees and graphs, and cover Dijkstra's Shortest Path Algorithm.  The course also includes an entire section devoted to Dynamic Programming.

Here's why this course is worth your time:

  • It's interactive -  I give you a chance to try every problem before I show you my solution.

  • Every single problem has a complete solution walkthrough video as well as accompanying solution file.

  • I cover helpful "tips and tricks" to solve common problems, but we also focus on building an approach to ANY problem.

  • It's full of animations and beautiful diagrams!

Who teaches JavaScript Algorithms and Data Structures Masterclass? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in JavaScript Algorithms and Data Structures Masterclass?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Curriculum Walkthrough
All Course Lessons (217)
#Lesson TitleDurationAccess
1
Curriculum Walkthrough Demo
07:44
2
What Order Should You Watch In?
02:53
3
How I'm Running My Code
03:22
4
Intro to Big O
07:42
5
Timing Our Code
10:20
6
Counting Operations
04:37
7
Visualizing Time Complexities
04:26
8
Official Intro to Big O
09:59
9
Simplifying Big O Expressions
09:33
10
Space Complexity
06:27
11
Logs and Section Recap
08:47
12
Section Introduction
01:43
13
The BIG O of Objects
05:32
14
When are Arrays Slow?
06:26
15
Big O of Array Methods
05:57
16
Introduction to Problem Solving
07:09
17
Step 1: Understand The Problem
08:00
18
Step 2: Concrete Examples
06:20
19
Step 3: Break It Down
07:45
20
Step 4: Solve Or Simplify
10:33
21
Step 5: Look Back and Refactor
16:58
22
Recap and Interview Strategies
04:13
23
Intro to Problem Solving Patterns
02:56
24
Frequency Counter Pattern
15:12
25
Frequency Counter: Anagram Challenge
02:34
26
Anagram Challenge Solution
06:19
27
Multiple Pointers Pattern
09:43
28
Multiple Pointers: Count Unique Values Challenge
04:30
29
Count Unique Values Solution
06:31
30
Sliding Window Pattern
13:15
31
Divide And Conquer Pattern
07:03
32
Story Time: Martin & The Dragon
07:07
33
Why Use Recursion?
05:54
34
The Call Stack
07:08
35
Our First Recursive Function
05:12
36
Our Second Recursive Function
07:55
37
Writing Factorial Iteratively
02:20
38
Writing Factorial Recursively
03:16
39
Common Recursion Pitfalls
05:07
40
Helper Method Recursion
06:24
41
Pure Recursion
07:46
42
Intro to Searching
04:05
43
Intro to Linear Search
04:48
44
Linear Search Solution
05:19
45
Linear Search BIG O
01:56
46
Intro to Binary Search
05:48
47
Binary Search PseudoCode
02:41
48
Binary Search Solution
16:42
49
Binary Search BIG O
06:10
50
Naive String Search
04:39
51
Naive String Search Implementation
12:30
52
Introduction to Sorting Algorithms
08:36
53
Built-In JavaScript Sorting
04:41
54
Bubble Sort: Overview
07:22
55
Bubble Sort: Implementation
09:59
56
Bubble Sort: Optimization
04:23
57
Bubble Sort: BIG O Complexity
01:29
58
Selection Sort: Introduction
06:19
59
Selection Sort: Implementation
11:15
60
Selection Sort: Big O Complexity
01:41
61
Insertion Sort: Introduction
03:18
62
Insertion Sort: Implementation
10:43
63
Insertion Sort: BIG O Complexity
02:25
64
Comparing Bubble, Selection, and Insertion Sort
05:34
65
Intro to the "Crazier" Sorts
06:06
66
Merge Sort: Introduction
05:26
67
Merging Arrays Intro
05:12
68
Merging Arrays: Implementation
06:56
69
Writing Merge Sort Part 1
02:22
70
Writing Merge Sort Part 2
12:38
71
Merge Sort BIG O Complexity
06:23
72
Introduction to Quick Sort
09:01
73
Pivot Helper Introduction
08:07
74
Pivot Helper Implementation
08:09
75
Quick Sort Implementation
08:47
76
Quick Sort Call Stack Walkthrough
04:16
77
Quick Sort Big O Complexity
04:07
78
Radix Sort: Introduction
09:23
79
Radix Sort: Helper Methods
11:10
80
Radix Sort: Pseudocode
04:19
81
Radix Sort: Implementation
10:25
82
Radix Sort: BIG O Complexity
03:52
83
Which Data Structure Is The Best?
12:39
84
ES2015 Class Syntax Overview
05:15
85
Data Structures: The Class Keyword
06:37
86
Data Structures: Adding Instance Methods
09:50
87
Data Structures: Adding Class Methods
07:12
88
Intro to Singly Linked Lists
07:47
89
Starter Code and Push Intro
07:23
90
Singly Linked List: Push Solution
04:25
91
Singly Linked List: Pop Intro
06:15
92
Singly Linked List: Pop Solution
07:36
93
Singly Linked List: Shift Intro
01:32
94
Singly Linked List: Shift Solution
03:23
95
Singly Linked List: Unshift Intro
01:35
96
Singly Linked List: Unshift Solution
05:59
97
Singly Linked List: Get Intro
02:33
98
Singly Linked List: Get Solution
03:33
99
Singly Linked List: Set Intro
01:27
100
Singly Linked List: Set Solution
02:11
101
Singly Linked List: Insert Intro
04:28
102
Singly Linked List: Insert Solution
07:50
103
Singly Linked List: Remove Intro
01:57
104
Singly Linked List: Remove Solution
03:16
105
Singly Linked List: Reverse Intro
04:47
106
Singly Linked List: Reverse Solution
08:59
107
Singly Linked List: BIG O Complexity
05:42
108
Doubly Linked Lists Introduction
04:44
109
Setting Up Our Node Class
03:01
110
Push
02:11
111
Push Solution
04:05
112
Pop
03:21
113
Pop Solution
06:24
114
Shift
02:45
115
Shift Solution
04:13
116
Unshift
01:37
117
Unshift Solution
02:20
118
Get
04:03
119
Get Solution
07:05
120
Set
01:19
121
Set Solution
02:09
122
Insert
02:51
123
Insert Solution
06:49
124
Remove
02:19
125
Remove Solution
06:29
126
Comparing Singly and Doubly Linked Lists
04:33
127
Intro to Stacks
06:20
128
Creating a Stack with an Array
07:06
129
Writing Our Own Stack From Scratch
11:34
130
BIG O of Stacks
02:15
131
Intro to Queues
04:15
132
Creating Queues Using Arrays
03:26
133
Writing Our Own Queue From Scratch
10:25
134
BIG O of Queues
02:31
135
Introduction to Trees
06:46
136
Uses For Trees
06:33
137
Intro to Binary Trees
05:55
138
POP QUIZ!
01:14
139
Searching A Binary Search Tree
02:56
140
Our Tree Classes
02:45
141
BST: Insert
03:51
142
BST: Insert Solution
11:54
143
BST: Find
04:43
144
BST: Find Solution
05:37
145
Big O of Binary Search Trees
05:59
146
Intro To Tree Traversal
04:51
147
Breadth First Search Intro
05:52
148
Breadth First Search Solution
06:21
149
Depth First PreOrder Intro
05:38
150
Depth First PreOrder Solution
06:51
151
Depth First PostOrder Intro
04:03
152
Depth First PostOrder Solution
02:39
153
Depth First InOrder Intro
02:08
154
Depth First InOrder Solution
02:33
155
When to Use BFS and DFS
07:38
156
Intro to Heaps
07:31
157
Storing Heaps
07:06
158
Heap: Insert Intro
09:15
159
Heap: Insert Solution
10:52
160
Heap: ExtractMax Intro
08:29
161
Heap: ExtractMax Solution
17:57
162
Priority Queue Intro
09:00
163
Priority Queue Pseudocode
03:44
164
Priority Queue Solution
09:22
165
BIG O of Binary Heaps
08:55
166
Intro to Hash Tables
05:51
167
More About Hash Tables
04:33
168
Intro to Hash Functions
06:12
169
Writing Our First Hash Function
08:28
170
Improving Our Hash Function
07:11
171
Handling Collisions
04:00
172
Hash Table Set and Get
04:03
173
Hash Table Set Solution
05:15
174
Hash Table Get Solution
06:44
175
Hash Table Keys and Values
01:42
176
Hash Table Keys and Values Solution
08:44
177
Hash Table Big O Complexity
05:42
178
Intro to Graphs
03:51
179
Uses for Graphs
07:58
180
Types of Graphs
08:49
181
Storing Graphs: Adjacency Matrix
03:58
182
Storing Graphs: Adjacency List
02:30
183
Adjacency Matrix Vs. List BIG O
05:52
184
Add Vertex Intro
02:11
185
Add Vertex Solution
02:55
186
Add Edge Intro
02:33
187
Add Edge Solution
02:12
188
Remove Edge Intro
01:36
189
Remove Edge Solution
02:42
190
Remove Vertex Intro
02:36
191
Remove Vertex Solution
04:35
192
Intro to Graph Traversal
08:39
193
Depth First Graph Traversal
08:31
194
DFS Recursive Intro
07:28
195
DFS Recursive Solution
12:46
196
DFS Iterative Intro
03:38
197
DFS Iterative Solution
08:45
198
Breadth First Graph Traversal
03:00
199
BFS Intro
02:28
200
BFS Solution
08:10
201
Intro to Dijkstra's and Prerequisites
02:42
202
Who was Dijkstra and what is his Algorithm?
09:01
203
Writing a Weighted Graph
05:21
204
Walking through the Algorithm
16:27
205
Introducing Our Simple Priority Queue
03:49
206
Dijkstra's Pseudo-Code
04:29
207
Implementing Dijkstra's Algorithm
21:19
208
Upgrading the Priority Queue
01:53
209
Intro to Dynamic Programming
05:04
210
Overlapping Subproblems
06:00
211
Optimal Substructure
06:29
212
Writing A Recursive Solution
06:44
213
Time Complexity of Our Solution
04:12
214
The Problem With Our Solution
03:40
215
Enter Memoization!
09:01
216
Time Complexity of Memoized Solution
03:28
217
Tabulation: A Bottom Up Approach
07:00
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to JavaScript Algorithms and Data Structures Masterclass?

More courses by Udemy

Frequently asked questions

What are the prerequisites for this course?
The course is designed for individuals who have a basic understanding of JavaScript. It assumes familiarity with fundamental programming concepts. It is beneficial if you have prior experience with JavaScript syntax and elementary programming tasks, but the course does not require any specific advanced knowledge in computer science before starting.
What kind of projects or exercises will I work on?
The course includes various challenges and exercises, such as the Anagram Challenge and Count Unique Values Challenge, which are part of the Problem Solving Patterns section. These exercises are designed to reinforce your understanding of algorithms and data structures, and they help prepare you for technical interviews.
Who is the target audience for this course?
This course is aimed at individuals preparing for technical interviews at major tech companies, such as Google, Tesla, Amazon, and Facebook. It is also suitable for anyone looking to solidify their understanding of algorithms and data structures, whether they are career switchers or recent graduates of coding bootcamps.
How does this course compare in depth to similar courses?
Unlike many introductory courses, this course covers advanced topics like Heaps, Graphs, and Dijkstra’s Shortest Path Algorithm. It goes beyond the basics to provide a deep dive into computer science concepts that are often reserved for higher-level courses or in-person bootcamps.
What specific algorithms are covered in this course?
The course covers a variety of algorithms, including but not limited to, Sorting Algorithms like Bubble Sort and Selection Sort, and Searching Algorithms such as Linear Search and Binary Search. It also includes more complex algorithms like those for Heaps and Graphs.
What is not covered in this course that I should be aware of?
The course focuses specifically on algorithms and data structures using JavaScript. It does not cover web development frameworks, front-end or back-end development practices, or other programming languages outside of JavaScript.
How much time should I expect to commit to this course?
The course consists of nearly 22 hours of video content spread across 217 lessons. Depending on your learning pace and the time you dedicate to exercises and review, it could take several weeks to complete if you study part-time. A full-time commitment could see completion in under a week.