What you’ll learn:
🔗 Learn everything you need to ace difficult coding interviews
🔗 Master dozens of popular algorithms, including 6 sorting algorithms!
🔗 Implement 10+ data structures from scratch
🔗 Improve your problem solving skills and become a stronger developer
Part 3
20. Doubly Linked Lists
- (00:00:00) Doubly Linked Lists Introduction
- (00:04:54) Setting Up Our Node Class
- (00:07:54) Push
- (00:10:05) Push Solution
- (00:14:09) Pop
- (00:17:29) Pop Solution
- (00:23:53) Shift
- (00:26:38) Shift Solution
- (00:30:49) Unshift
- (00:32:25) Unshift Solution
- (00:34:45) Get
- (00:38:47) Get Solution
- (00:45:52) Set
- (00:47:10) Set Solution
- (00:49:18) Insert
- (00:52:09) Insert Solution
- (00:58:57) Remove
- (01:01:16) Remove Solution
- (01:07:44) Comparing Singly and Doubly Linked Lists
- Stacks + Queues
- (01:12:16) Intro to Stacks
- (01:18:35) Creating a Stack with an Array
- (01:25:41) Writing Our Own Stack From Scratch
- (01:37:14) BIG O of Stacks
- (01:39:29) Intro to Queues
- (01:43:44) Creating Queues Using Arrays
- (01:47:09) Writing Our Own Queue From Scratch
- (01:57:33) BIG O of Queues
- Binary Search Trees
- (02:00:04) Introduction to Trees
- (02:06:50) Uses For Trees
- (02:13:22) Intro to Binary Trees
- (02:19:16) POP QUIZ!
- (02:20:30) Searching A Binary Search Tree
- (02:23:25) Our Tree Classes
- (02:26:09) BST: Insert
- (02:30:01) BST: Insert Solution
- (02:41:53) BST: Find
- (02:46:36) BST: Find Solution
- (02:52:12) Big O of Binary Search Trees
- Tree Traversal
- (02:58:05) Intro To Tree Traversal
- (03:02:55) Breadth First Search Intro
- (03:08:46) Breadth First Search Solution
- (03:15:06) Depth First PreOrder Intro
- (03:20:43) Depth First PreOrder Solution
- (03:27:33) Depth First PostOrder Intro
- (03:31:35) Depth First PostOrder Solution
- (03:34:13) Depth First InOrder Intro
- (03:36:20) Depth First InOrder Solution
- (03:39:03) When to Use BFS and DFS
- Binary Heaps
- (03:46:41) Intro to Heaps
- (03:54:11) Storing Heaps
- (04:01:17) Heap: Insert Intro
- (04:10:32) Heap: Insert Solution
- (04:21:23) Heap: ExtractMax Intro
- (04:29:52) Heap: ExtractMax Solution
- (04:47:43) Priority Queue Intro
- (04:56:47) Priority Queue Pseudocode
- (05:00:30) Priority Queue Solution
- (05:09:51) BIG O of Binary Heaps
- Hash Tables
- (05:18:46) Intro to Hash Tables
- (05:24:36) More About Hash Tables
- (05:29:08) Intro to Hash Functions
- (05:35:20) Writing Our First Hash Function
- (05:43:46) Improving Our Hash Function
- (05:50:57) Handling Collisions
- (05:54:57) Hash Table Set and Get
- (05:58:49) Hash Table Set Solution
- (06:04:14) Hash Table Get Solution
- (06:10:57) Hash Table Keys and Values
- (06:12:39) Hash Table Keys and Values Solution
- (06:21:22) Hash Table Big O Complexity
- Graphs
- (06:27:04) Intro to Graphs
- (06:30:54) Uses for Graphs
- (06:38:52) Types of Graphs
- (06:47:41) Storing Graphs: Adjacency Matrix
- (06:51:38) Storing Graphs: Adjacency List
- (06:54:15) Adjacency Matrix Vs. List BIG O
- (06:59:59) Add Vertex Intro
- (07:02:09) Add Vertex Solution
- (07:05:03) Add Edge Intro
- (07:07:35) Add Edge Solution
- (07:09:46) Remove Edge Intro
- (07:11:22) Remove Edge Solution
- (07:14:15) Remove Vertex Intro
- (07:16:40) Remove Vertex Solution
- Graph Traversal
- (07:21:14) Intro to Graph Traversal
- (07:29:52) Depth First Graph Traversal
- (07:38:23) DFS Recursive Intro
- (07:45:51) DFS Recursive Solution
- (07:58:36) DFS Iterative Intro
- (08:02:14) DFS Iterative Solution
- (08:10:58) Breadth First Graph Traversal
- (08:13:58) BFS Intro
- (08:16:24) BFS Solution
- Dijkstra’s Algorithm!
- (08:24:34) Intro to Dijkstra’s and Prerequisites
- (08:27:15) Who was Dijkstra and what is his Algorithm?
- (08:36:16) Writing a Weighted Graph
- (08:41:35) Walking through the Algorithm
- (08:58:02) Introducing Our Simple Priority Queue
- (09:01:51) Dijkstra’s Pseudo-Code
- (09:06:19) Implementing Dijkstra’s Algorithm
- (09:27:38) Upgrading the Priority Queue
- Dynamic Programming
- (09:29:31) Intro to Dynamic Programming
- (09:34:34) Overlapping Subproblems
- (09:40:15) Optimal Substructure
- (09:47:02) Writing A Recursive Solution
- (09:53:45) Time Complexity of Our Solution
- (09:57:57) The Problem With Our Solution
- (10:01:36) Enter Memoization!
- (10:10:37) Time Complexity of Memoized Solution
- (10:14:04) Tabulation: A Bottom Up Approach
#javascript #algorithms #data-structures
7.45 GEEK