JavaScript Algorithms and Data Structures Masterclass

21:47:46 Inglés Premium 18/05/2023 217 videos

Descripción del curso

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!

Curriculum

Section 1: Module 1

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

About the Instructor

udemy

$0.00

$8.00

Que esta incluido?

Streaming Multiplataforma
Acceso de por vida
Soporte al cliente
Actualizaciones gratuitas