The Roadmap

The five-course training menu

A serious culinary training program doesn't teach dishes in a random order. It teaches knife skills before sauces, sauces before composed plates, because each course leans on what the last one built into your hands. The 24 modules in this course are grouped into five stages the same way. The order isn't arbitrary — each stage leans on the ones before it, and most confusion in DSA comes from meeting ideas before their prerequisites.

1. Stage 0 — Foundations

   How to Learn This Course · Big O & Complexity Analysis · Math for DSA

   Knife skills and pantry basics. Big O is the vocabulary the entire course is written in, so it comes first and gets a full module — not a cheat sheet. The math module covers the small set of tools (logarithms, modular arithmetic, counting) that later modules quietly depend on.

2. Stage 1 — Linear structures

   Arrays · Strings · Hash Tables · Linked Lists · Stacks · Queues

   The raw ingredients every later dish is built from. Everything here is about memory: contiguous versus linked layout, what a pointer really is, why resizing a dynamic array is still cheap on average, how hashing turns "search everything" into "go directly there." These six structures are the raw material for every later stage.

3. Stage 2 — Techniques on linear data

   Two Pointers · Sliding Window · Prefix Sum · Binary Search · Sorting · Matrix Traversal

   Not new ingredients — new techniques applied to the ingredients you just prepped. Each one converts a brute-force quadratic scan into linear or logarithmic work, and each comes with the argument for why the shortcut is safe (why can binary search discard half the array? why can the window never miss the answer?).

4. Stage 3 — Recursive & hierarchical

   Recursion & Backtracking · Binary Trees · BST & Ordered Structures · Heaps · Tries

   Composed dishes — built from smaller cooked components stacked on each other. Recursion is taught as a tool in its own right — the call-stack model, then divide & conquer, then systematic search over choice trees. The tree-shaped structures follow, each defined by one invariant: the BST's ordering, the heap's parent-beats-child, the trie's shared prefixes.

5. Stage 4 — Global reasoning

   Intervals · Greedy · Graphs · Dynamic Programming

   The full tasting menu, where every skill from the earlier courses has to work together at once. Problems where the answer depends on the whole input at once. Greedy is taught with exchange arguments — proving the greedy choice is safe, since "it felt locally best" is how greedy solutions go wrong. Graphs and DP are the two biggest modules in the course, each internally staged.

How to move through it

• In order, if you're building from scratch. The dependencies are real.
• Jump in, if you're refreshing. Each module states what it assumes. If a module feels hard in a "missing pieces" way rather than a "new idea" way, back up one stage.
• Don't stockpile theory. A stage's techniques only settle once you've done its problems. Finish a module's problems before starting the next module — momentum through problems beats coverage of prose.

Next stop: Big O & Complexity Analysis — the language everything else is written in.