Quicksort Learn Algorithms · 3:54 Quicksort breaks down the art of efficient sorting by introducing the divide-and-conquer strategy, showing how choosing a pivot element and partitioning an array into smaller and larger values leads to a powerfully fast recursive solution.
Binary search Learn Algorithms · 2:49 Dive into the power of binary search, the efficient algorithm that slashes search time by repeatedly halving a sorted list to pinpoint any element in milliseconds rather than checking every item one by one.
Counting sort Learn Algorithms · 3:01 Counting sort breaks down an efficient, range-based sorting technique that skips comparisons entirely by tracking element frequencies, showing how knowing your data's boundaries can unlock lightning-fast sorting performance.
Floyd-Warshall algorithm Learn Algorithms · 2:24 Dive into the Floyd-Warshall algorithm and discover how to find the shortest paths between every pair of nodes in a weighted, directed graph, starting with distance matrix initialization and building toward a complete all-pairs solution.
A* search Learn Algorithms · 2:19 Dive into A* search, the powerful pathfinding algorithm that combines Dijkstra's reliability with heuristic guidance to efficiently navigate from start to goal, and discover how distance functions like Manhattan and Euclidean help prioritize the most promising paths.
Kruskal's algorithm Learn Algorithms · 3:34 Dive into Kruskal's algorithm and discover how to find the minimum spanning tree of a weighted graph by sorting edges and using a Union-Find structure to avoid cycles.
Levenshtein distance (edit distance) Learn Algorithms · 2:54 Levenshtein distance measures how "far apart" two strings are by counting the minimum insertions, deletions, and substitutions needed to transform one into the other — a foundational concept in spell-checking, DNA analysis, and fuzzy search built through dynamic programming.
Boyer-Moore Learn Algorithms · 2:31 Dive into Boyer-Moore, a powerful string-searching algorithm that uses two clever heuristics—bad character and good suffix rules—to skip unnecessary comparisons and find patterns far faster than brute-force scanning.
Longest common subsequence Learn Algorithms · 2:44 Dive into the classic dynamic programming problem of finding the longest common subsequence between two strings, where you'll learn how to build a step-by-step table to efficiently identify shared characters even when they aren't side by side.
Knapsack (0/1 and unbounded) Learn Algorithms · 3:02 A deep dive into the classic knapsack problem, exploring both zero-one and unbounded variations using dynamic programming to maximize value within weight constraints.
Matrix chain multiplication Learn Algorithms · 2:36 Dive into the fascinating world of matrix chain multiplication, where the order in which you group and compute a sequence of matrices can make the difference between an efficient algorithm and an exponentially costly one.
Red-black tree balancing Learn Algorithms · 2:59 Dive into the world of red-black trees, a self-balancing data structure that solves the performance pitfalls of unbalanced binary trees by strategically coloring nodes red or black to keep search times efficient.
Consistent hashing Learn Algorithms · 3:07 Consistent hashing solves the painful problem of massive data redistribution when servers are added or removed from a cluster. You'll learn how this elegant technique minimizes key relocation by mapping both data and nodes onto a virtual ring, making distributed systems far more resilient and scalable.
Karatsuba multiplication Learn Algorithms · 3:08 Discover how Karatsuba multiplication breaks large numbers into smaller pieces using a divide-and-conquer approach, slashing the time complexity of traditional multiplication from n-squared down to something far more efficient.
Closest pair of points Learn Algorithms · 3:14 Dive into the classic computational geometry problem of finding the closest pair of points, where you'll discover how divide and conquer slashes brute force's n-squared complexity into a far more elegant solution.
Huffman coding Learn Algorithms · 3:04 Dive into the world of data compression with Huffman coding, discovering how variable-length codes cleverly assign shorter sequences to common symbols and longer ones to rare characters, reducing file sizes by building a frequency-based tree from the ground up.
Edmonds-Karp Learn Algorithms · 2:39 Dive into the Edmonds-Karp algorithm, a powerful variant of Ford-Fulkerson that solves the maximum flow problem in network graphs by efficiently finding the optimal path from source to sink. You'll discover how this approach cuts through complexity when thousands of possible paths exist, giving you a reliable strategy for tackling real-world flow optimization challenges.
Extended Euclidean algorithm Learn Algorithms · 2:48 Diving deep into the Extended Euclidean Algorithm, this lesson builds on Euclid's classic method to show how tracking coefficients and linear combinations unlocks not just the greatest common divisor, but the mathematical relationships between numbers that power modern cryptography and beyond.
Modular exponentiation Learn Algorithms · 2:44 Modular exponentiation tackles the challenge of computing massive powers efficiently without overwhelming memory or time. Listeners will discover how breaking exponents into smaller pieces and applying modular arithmetic makes cryptographic and computational problems fast and feasible.
RSA key generation basics Learn Algorithms · 2:34 Dive into the fascinating world of RSA encryption as you learn how large prime numbers P and Q are selected and combined to generate a secure modulus, uncovering the mathematical foundations that keep modern cryptography strong.
Radix sort Learn Algorithms · 3:34 Dive into Radix sort, a powerful non-comparative algorithm that tackles integer sorting by processing digits one at a time, from least to most significant. Learn how this clever approach outperforms traditional sorting methods when dealing with massive ranges of sparse data.
Counting sort Learn Algorithms · 3:49 Counting sort breaks down an efficient sorting technique that works by mapping values to array indices, revealing when and why this algorithm shines with its linear time complexity for datasets with a limited numerical range.
Binary search Learn Algorithms · 4:48 A deep dive into binary search, one of computing's most elegant algorithms, teaching you how to efficiently locate values in sorted lists using strategic midpoint calculations instead of slow, exhaustive scanning.
Linear search Learn Algorithms · 3:49 A foundational search algorithm comes to life as linear search walks through arrays one element at a time, teaching listeners how to systematically check each index from zero until a match is found.
Interpolation search Learn Algorithms · 4:17 Interpolation search builds on binary search by using the actual value of the target to predict its likely position, making it significantly faster when data is uniformly distributed.
Depth-first search (DFS) Learn Algorithms · 3:24 Dive deep into Depth-First Search, a powerful graph traversal algorithm that explores as far as possible along each path before backtracking, using either a stack or recursion to systematically visit every node.
Floyd-Warshall algorithm Learn Algorithms · 3:05 Dive into the Floyd-Warshall algorithm and discover how three nested loops can efficiently find the shortest paths between every pair of nodes in a graph by systematically testing each vertex as an intermediate stop.
A* search Learn Algorithms · 3:21 Dive into A* search, the powerful pathfinding algorithm that combines Dijkstra's precision with heuristic guidance to efficiently find the shortest route from start to goal. You'll learn how admissible heuristics like Manhattan distance supercharge the search, making it faster and smarter than traditional approaches.
Prim's algorithm Learn Algorithms · 5:09 Dive into Prim's algorithm and discover how to efficiently build a minimum spanning tree by strategically selecting vertices and weighted edges from a graph. You'll learn the step-by-step process of growing a tree from a single starting point while minimizing total edge weight.
Rabin-Karp Learn Algorithms · 3:56 Dive into the Rabin-Karp string searching algorithm, where rolling hash functions and modular arithmetic transform pattern matching into an elegant fingerprinting technique that efficiently scans text one window at a time.
Aho-Corasick Learn Algorithms · 5:17 Dive into the Aho-Corasick algorithm, a powerful method for efficiently searching multiple patterns within a string simultaneously. You'll learn how building a trie and leveraging failure links transforms a slow brute-force approach into an elegant, high-performance solution.
Boyer-Moore Learn Algorithms · 4:01 Dive into the Boyer-Moore string search algorithm, discovering how its clever bad character and good suffix tables allow patterns to skip ahead rather than crawl through text one character at a time.
Longest common subsequence Learn Algorithms · 3:27 Dive into the classic dynamic programming problem of finding the longest common subsequence between two strings, where you'll learn how to identify shared elements in order while skipping gaps, building an efficient solution step by step.
Quicksort Learn Algorithms · 3:29 Dive into Quicksort, one of computer science's most elegant sorting algorithms, as you discover how Tony Hoare's brilliant pivot-and-partition strategy uses recursion to efficiently organize even the most chaotic arrays.
Quicksort Fundamentals: Divide and Conquer Strategy Learn Algorithms · 3:54 Dive into the elegant world of Quicksort, one of the most powerful sorting algorithms, and discover how choosing a pivot element and strategically partitioning data into smaller and larger halves can efficiently sort entire arrays through recursive divide and conquer logic.
Partition Logic: The Heart of Quicksort Learn Algorithms · 4:14 Dive into the core mechanism that makes Quicksort tick — the partition step — where two pointers march toward each other, swapping elements until every value lands on the correct side of a chosen pivot.
Quicksort Performance: Best, Average, and Worst Cases Learn Algorithms · 4:03 Diving into the mechanics of Quicksort, this track breaks down how pivot selection and partitioning drive performance across best, average, and worst-case scenarios, giving you a clear grasp of why time complexity varies and what that means for real-world sorting efficiency.
Quicksort Gotchas: Edge Cases and Optimization Tricks Learn Algorithms · 3:44 Dive into the common pitfalls that trip up developers when implementing quicksort, from null pointer errors to missing base cases, and discover the essential edge case checks and optimization strategies that will make your quicksort implementation bulletproof.
Mergesort Learn Algorithms · 4:45 Dive into the elegant world of Mergesort, a powerful divide-and-conquer algorithm that breaks arrays down to their simplest form before rebuilding them in perfect order. You'll learn how recursive splitting and base cases work together to efficiently tackle even the messiest sorting challenges.
Heapsort Learn Algorithms · 4:50 Heapsort breaks down one of computer science's most efficient sorting algorithms, walking you through how to transform a chaotic array into perfectly ordered data using a binary heap structure.
Insertion sort Learn Algorithms · 4:29 Insertion sort breaks down one of the most intuitive sorting algorithms, showing you how to efficiently build a sorted sequence by picking each element and sliding it into its correct position — just like organizing a hand of playing cards.
Bubble sort Learn Algorithms · 4:20 A deep dive into one of the most fundamental sorting algorithms, bubble sort teaches you how repeated comparisons and swaps gradually push the largest values to their correct positions — and why simplicity doesn't always mean efficiency.
Timsort Learn Algorithms · 3:59 Dive into Timsort, Python's powerful hybrid sorting algorithm that combines the simplicity of insertion sort with the efficiency of merge sort to handle real-world data with impressive speed.
Exponential search Learn Algorithms · 3:09 Exponential search combines range-finding with binary search to efficiently locate targets in sorted arrays, teaching you how doubling index bounds before narrowing down can outpace traditional approaches for large datasets.
Breadth-first search (BFS) Learn Algorithms · 3:23 Breadth-first search (BFS) breaks down one of the most fundamental graph traversal algorithms, showing how it systematically explores nodes level by level using a queue to guarantee the shortest path in unweighted graphs.
What is Dijkstra's Algorithm? Learn Algorithms · 3:55 Dive into Dijkstra's Algorithm, the classic graph-traversal method for finding the shortest weighted path between nodes. You'll learn how priority queues, distance initialization, and step-by-step vertex exploration work together to efficiently solve real-world routing problems.
Graph Theory Basics for Shortest Paths Learn Algorithms · 3:57 Dive into the fundamentals of graph theory and discover how nodes, edges, and weights form the foundation for solving shortest path problems, with an introduction to key algorithms like Dijkstra's and BFS.
How Dijkstra's Algorithm Works Learn Algorithms · 3:49 A deep dive into Dijkstra's Algorithm, one of computer science's most elegant pathfinding solutions, teaching you how weighted graphs, priority queues, and greedy choices combine to efficiently calculate the shortest route between nodes.
Dijkstra vs Other Path-Finding Algorithms Learn Algorithms · 4:16 Dive into the world of shortest path algorithms as Dijkstra's greedy, priority-queue-driven approach goes head-to-head with alternatives, revealing when each method shines and where negative weights can cause Dijkstra to fall short.
Implementation and Time Complexity Learn Algorithms · 3:54 Diving into the practical side of algorithm design, this track breaks down Big O notation and time complexity, showing how different data structures like hash tables and arrays affect the speed and efficiency of your code.