Curriculum
Course overview
24 modules, built in order. Every structure taught from first principles — how it works in memory, what operations really cost and why, implemented from scratch — then drilled with solve-first problems and quizzes.
24 of 24 modules live — the rest are being written in curriculum order.
Stage 0 — Foundations
How the course works, and the analysis toolkit every later module leans on.
How to Learn This Course
What this course is, how lessons and the in-browser sandbox work, and how to pace yourself.
Big O & Complexity Analysis
Measure algorithms by how they scale — the vocabulary the rest of the course is written in.
Math for DSA
Logarithms, modular arithmetic, and counting — just enough math, properly understood.
Stage 1 — Linear Structures
The core containers — how they sit in memory and what their operations really cost.
Arrays & Dynamic Arrays
Contiguous memory, cache locality, resizing amortization, and in-place techniques.
Strings
Immutability, builders, encodings, and the standard transformation toolkit.
Hash Tables
Hash functions, collisions, keys, and the four usage patterns — then the problems they unlock.
Linked Lists
Node-and-pointer memory model, core operations, in-place reversal, fast & slow pointers.
Stacks
LIFO discipline, the call stack, expression problems, and the monotonic stack.
Queues
FIFO, deques, ring buffers, and the monotonic queue.
Stage 2 — Techniques on Linear Data
Algorithmic techniques that turn quadratic scans into linear or logarithmic work.
Two Pointers
Opposite-direction and same-direction pointer walks, and why they're correct.
Sliding Window
Fixed and dynamic windows — maintaining an invariant while the window moves.
Prefix Sum
Precomputed running totals, prefix-sum + hash map, 2D grids, and Kadane's algorithm.
Binary Search
The invariant-driven template, boundary variants, and binary search on the answer.
Sorting
Comparison sorts and their lower bound, linear-time sorts, stability, and when each wins.
Matrix / 2D Traversal
Grid coordinates, traversal orders, and in-place matrix transformations.
Stage 3 — Recursive & Hierarchical
Recursion as a tool, then the tree-shaped structures built on it.
Recursion & Backtracking
The call-stack model, divide & conquer, and systematic search over choice trees.
Binary Trees
Tree anatomy, all four traversals, and reconstruction from traversal orders.
BST & Ordered Structures
The ordering invariant, balance (AVL / red-black conceptually), and ordered-set applications.
Heaps
Array-backed complete trees, heapify's real cost, two-heaps, k-way merge, top-k.
Tries
Prefix trees — building, searching, and when they beat hash tables.
Stage 4 — Global Reasoning
Problems where the answer depends on the whole input — greedy proofs, graphs, DP.
Intervals
Sorting by endpoints, merging, and scheduling — the sweep mindset.
Greedy
Exchange arguments — proving the greedy choice is safe, not just hoping.
Graphs
Representations, BFS/DFS, topological sort, union-find, shortest paths, MST.
Dynamic Programming
Overlapping subproblems from first principles — 1-D, knapsack, LIS, grid, string, tree DP.