Graph Algorithms: BFS and DFS
Breadth-first and depth-first search differ by exactly one data structure: a queue versus a stack. This video traces both traversals on real graphs, showing the frontier as it grows, what the visited set must remember, and why the choice changes which problems each algorithm solves.
Topics covered:
- The only difference: queue vs stack, and why it matters
- Traversal order traced node by node on sample graphs
- The visited set: what the machine must remember
- BFS layers and shortest paths in unweighted graphs
- DFS recursion and the call stack as the implicit stack
- Applications: connected components, topological sort, cycle detection
Related articles
Big-O Measures Scaling, Not Speed
O(n) says nothing about how fast your code is today — it predicts how it behaves as the input grows. What complexity analysis is really for, and when it misleads.
Hash Tables Aren't Magic
Load factors, collision strategies, and cache misses — why O(1) has a constant that bites when you least expect it.
Amortized Analysis: When O(1) Is Really O(1)
Master aggregate, accounting, and potential methods to prove that worst-case-per-operation bounds hold even when individual operations are expensive.
More in Algorithms
Hash Tables Under the Hood
Load factors, collision strategies, and cache behavior — why O(1) has a constant that can be 1ns or 200ns.
WatchTries and String Search
Tries, radix trees, and Aho-Corasick — how prefix structures make lookups proportional to key length, not dataset size.
DetailsHeaps and Priority Queues
Binary heaps as arrays — sift up, sift down, and why insert and extract-min are both O(log n) with no pointers.
DetailsHash Maps and Collision Resolution
Hash maps from the memory up — hash functions, collision strategies, and the load factor that decides when a map resizes.
DetailsDynamic Programming, Visualized
Memoization and tabulation as data flow — overlapping subproblems, the DP table, and how state transitions map to code.
DetailsBinary Search Explained
Binary search at the instruction level — midpoint math, cache behavior, and why it beats linear scan on sorted contiguous data.
DetailsRecursion and the Call Stack
How recursive functions actually execute — stack frames, the base case, and what happens to memory when recursion goes deep.
DetailsBig-O Notation, Visually Explained
What O(1), O(n), and O(log n) mean as instruction counts — growth curves drawn to scale, constants, and real workloads.
DetailsSorting Algorithms Under the Hood
Quicksort, merge sort, and insertion sort compared by the operations that matter: comparisons, swaps, cache misses, and allocations.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.