Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Algorithms and Data Structures Masterclass in Python
Introduction
Introduction (2:10)
### RECURSION ###
What are stack and heap memory? (3:44)
Stack memory and heap memory simulation (6:14)
What is recursion (recursive function call)? (6:55)
Recursion and stack memory (stack overflow) (10:09)
Factorial problem - with head recursion (6:11)
Factorial problem - visualizing the stack (4:14)
Transforming a head recursion into a tail recursion (5:19)
Fibonacci numbers problem - with head recursion (6:44)
Fibonacci numbers - visualizing the stack memory (8:59)
Towers of Hanoi introduction (6:18)
Towers of Hanoi implementation (7:56)
Towers of Hanoi - visualizing the stack (7:08)
What is the Euclidean algorithm? (5:59)
Euclidean algorithm implementation (3:41)
Recursion and iteration revisited (1:39)
### SELECTION ALGORITHMS ###
What is linear search? (1:38)
Linear search implementation (3:11)
What is binary (logarithmic) search? (3:48)
Binary search implementation (8:23)
### BACKTRACKING ###
What is backtracking? (16:00)
Brute-force search and backtracking (13:53)
N-queens problem introduction (4:17)
What is the search tree? (3:09)
N-queens problem implementation I (12:20)
N-queens problem implementation II (9:36)
N-queens problem and stack memory visualization (6:21)
Hamiltonian paths (and cycles) introduction (8:02)
Hamiltonian cycle illustration (4:41)
Hamiltonian path implementation I (5:05)
Hamiltonian path implementation II (6:38)
Coloring problem introduction (8:48)
Coloring problem visualization (4:32)
Coloring problem implementation (10:48)
Knight's tour introduction (3:54)
Knight's tour implementation I (13:01)
Knight's tour implementation II (5:22)
Maze problem introduction (4:58)
Maze problem implementation (16:14)
What is the problem with backtracking? (5:04)
### DYNAMIC PROGRAMMING ###
Dynamic programming introduction (8:23)
Fibonacci numbers introduction (3:30)
Fibonacci numbers implementation (7:57)
Knapsack problem introduction (18:06)
Knapsack problem example (12:58)
Knapsack problem implementation (10:07)
Rod cutting problem introduction (8:03)
Rod cutting problem example (11:06)
Rod cutting problem implementation (8:48)
Subset sum problem introduction (10:11)
Subset sum problem example (9:08)
Subset sum implementation (10:33)
###Â DATA STRUCTURES ###
Why to use data structures (4:49)
Data structures and abstract data types (3:33)
Data Structures - Arrays
What are array data structures? (6:55)
Arrays introduction - operations (6:56)
Arrays in Python (8:04)
What are real arrays in Python? (3:54)
Data Structures - Linked Lists
What are linked lists? (4:53)
Linked list introduction - operations (11:03)
Linked list implementation I (8:42)
Linked list implementation II (4:40)
Linked list implementation III (7:01)
Revisiting remove operation
Comparing linked lists and arrays (6:26)
What are doubly linked lists? (6:59)
Doubly linked list implementation (8:11)
Running time comparison: linked lists and arrays (3:57)
Practical (real-world) applications of linked lists (5:04)
Data Structures - Stacks
What are stacks? (4:35)
Stacks in memory management (stacks and heaps) (3:43)
Stack memory visualization (6:19)
Stack implementation (8:41)
Practical (real-world) applications of stacks (3:56)
Data Structures - Queues
What are queues? (4:15)
Queue implementation (8:36)
Data Structures - Binary Search Trees
What are binary search trees? (14:38)
Binary search trees theory - search, insert (7:55)
Binary search trees theory - delete (6:12)
Binary search trees theory - in-order traversal (5:28)
Binary search trees theory - running times (4:35)
Binary search tree implementation I (8:38)
Binary search tree implementation II (8:39)
Stack memory visualization - finding max (min) items (4:39)
Stack memory visualization - tree traversal (6:00)
Binary search tree implementation III - remove operation (18:09)
Practical (real-world) applications of trees (3:02)
Data Structures - AVL Trees
Motivation behind balanced binary search trees (3:26)
What are AVL trees? (6:47)
AVL trees introduction - height (12:38)
AVL trees introduction - rotations (9:05)
AVL trees introduction - illustration (5:17)
AVL tree implementation I (9:47)
AVL tree implementation II (9:38)
AVL tree implementation III (12:05)
AVL tree implementation IV (7:51)
AVL tree implementation V (2:20)
Practical (real-world) applications of balanced binary search trees (3:40)
Data Structures - Red-Black Trees
What are red-black trees? (10:48)
The logic behind red-black trees (4:26)
Red-black trees - recoloring and rotation cases (9:25)
Red-black tree illustrations (7:33)
Red-black tree implementation I (6:51)
Red-black tree implementation II (5:33)
Red-black tree implementation III (9:57)
Red-black tree implementation IV (2:10)
Differences between red-black tree and AVL trees (2:46)
Data Structures - Heaps
What are priority queues? (4:31)
Heap introduction - basics (10:14)
Heap introduction - array representation (9:36)
Heap introduction - remove operation (7:12)
Using heap data structure to sort (heapsort) (6:25)
Heap implementation I (5:11)
Heap implementation II (10:18)
Heap implementation III (4:31)
Heaps in Python (3:56)
Binomial and Fibonacci heaps (4:17)
Data Structures - Associative Arrays (Dictionaries)
What are associative arrays? (5:51)
Hashtable introduction - basics (11:25)
Hashtable introduction - collisions (11:19)
Hashtable introduction - dynamic resizing (7:08)
Linear probing implementation I (6:03)
Linear probing implementation II (6:27)
Linear probing implementation III (2:14)
Dictionaires in Python (3:40)
Why to use prime numbers in hashing? (6:21)
Practical (real-world) applications of hashing (6:31)
### GRAPH ALGORITHMS ###
Graph theory overview (6:45)
Adjacency matrix and adjacency list (7:58)
Applications of graphs (3:37)
Graph Algorithms - Graph Traversal Algorithms
Breadth-first search introduction (9:31)
Breadth-first search implementation (8:00)
What are WebCrawlers (core of search engines)? (5:49)
WebCrawler basic implementation (9:42)
Depth-first search introduction (10:22)
Depth-first search implementation (5:58)
Depth-first search recursive implementation (2:54)
Depth-first search and stack memory visualisation (6:01)
Memory management: BFS vs DFS (4:18)
Graph Algorithms - Shortest Paths with Dijkstra's Algorithm
What is the shortest path problem? (4:50)
Dijkstra algorithm visualization (11:04)
Dijkstra algorithm implementation I - Edge, Node (10:34)
Dijkstra algorithm implementation II - algorithm (13:58)
Dijkstra algorithm implementation III - testing (3:55)
Dijktsra's algorithm with adjacency matrix representation (12:10)
Adjacency matrix representation implementation (12:46)
Shortest path algorithms applications (5:08)
What is the critical path method (CPM)? (4:10)
Graph Algorithms - Shortest Paths with Bellman-Ford Algorithm
What is the Bellman-Ford algorithm? (13:41)
Bellman-Ford algorithm visualization (5:20)
Bellman-Ford algorithm implementation I - Node, Edge (1:38)
Bellman-Ford algorithm implementation II - the algorithm (7:46)
Bellman-Ford algorithm implementation III - testing (3:21)
Greedy algorithm or dynamic programming approach? (5:45)
Graph Algorithms - Spanning Trees with Kruskal Algorithm
What is the disjoint set data structure? (14:13)
Disjoint sets visualization (5:53)
Kruskal's algorithm introduction (10:08)
Kruskal algorithm implementation I - basic classes (6:28)
Kruskal algorithm implementation II - disjoint set (13:02)
Kruskal algorithm implementation III - algorithm (5:14)
Kruskal algorithm implementation VI - testing (3:25)
Graph Algorithms - Spanning Trees with Prims Algorithm
What is the Prim-Jarnik algorithm? (9:36)
Prims-Jarnik algorithm implementation I (10:26)
Prims-Jarnik algorithm implementation II (3:14)
Comparing the spanning tree approaches (2:08)
Applications of spanning trees (6:10)
Hamiltonian Cycles - Travelling Salesman Problem
What are Hamiltonian cycles? (11:19)
The travelling salesman problem (2:35)
Travelling salesman problem implementation (17:52)
TSP and stack memory visualization (11:58)
Why to use meta-heuristics? (5:20)
### SORTING ALGORITHM ###
Sorting introduction (7:36)
What is stability in sorting? (6:09)
What is adaptive sorting? (3:14)
Bogo sort introduction (3:14)
Bogo sort implementation (7:53)
Bubble sort introduction (5:27)
Bubble sort implementation (5:31)
Selection sort introduction (5:14)
Selection sort implementation (5:29)
Insertion sort introduction (8:35)
Insertion sort implementation (5:23)
Shell sort introduction (6:18)
Shell sort implementation (6:27)
Quicksort introduction (12:15)
Quicksort implementation (11:36)
What is the worst-case scenario for quicksort? (7:20)
Merge sort introduction (8:17)
Merge sort implementation (8:22)
Counting sort implementation (9:48)
Hybrid algorithms introduction (6:09)
Non-comparison based algorithms (2:13)
Counting sort introduction (10:17)
Stack memory and merge sort visualization (7:49)
Radix sort introduction (13:03)
Radix sort implementation (13:37)
Measure running time differences
### SUBSTRING SEARCH ALGORITHM ###
Brute-force search introduction (6:52)
Brute-force substring search algorithm implementation (6:30)
Rabin-Karp algorithm introduction (20:28)
Rabin-Karp algorithm implementation (14:56)
Knuth-Morris-Pratt algorithm introduction (12:54)
Constructing the partial match table - visualization (8:10)
Knuth-Morris-Pratt algorithm implementation (9:18)
Z algorithm introduction (19:30)
Z algorithm illustration (12:49)
Z algorithm implementation (16:12)
Substring search algorithms comparison (5:11)
Applications of substring search (2:21)
FREE Algorithms Visualizer App
Algorithms and Data Structures Visualization App (0:41)
Download the app
Course Materials (DOWNLOADS)
Source code and slides
Stack memory and heap memory simulation
Complete and Continue