A PATH, NOT A PILE OF LINKS
Build from the ground up.
Each topic builds on the last. Follow the order, find the pattern, then make it your own.
Start with Core. Go deeper with Plus.
Core gives you the essential patterns. Plus adds variations and harder challenges. There’s no deadline here—just a direction.
Foundations
Start here even if you have coded before. These eight teach you to reach for a hash map, a running best and a pair of pointers without thinking — the three reflexes every later step assumes you already have.
Arrays & Hashing
The step that pays for itself fastest. Roughly one interview question in four is a hash map used well, and the counting tricks here (prefix counts, frequency maps, Boyer-Moore) show up again inside harder problems all the way to the end of the sheet.
Two Pointers
Sorted input, or input you are allowed to sort, plus two indices moving with intent. Learn to justify why moving a pointer can never lose the answer — that argument is what interviewers are actually listening for here.
Sliding Window
A window is two pointers plus an invariant you restore by shrinking from the left. Every problem here is the same loop; what changes is what you keep in the window and what makes it invalid.
Prefix Sums & Matrices
Two small, high-yield toolkits. Prefix sums turn range questions into subtraction; matrix problems are almost entirely about index discipline, which is exactly what a whiteboard punishes.
Binary Search
The highest ratio of "interviews it appears in" to "time it takes to learn" on the whole sheet. Get the boundary template exactly right once, then spend the rest of the step learning to search over an ANSWER rather than over an array.
Stacks, Queues & Monotonic Stacks
A stack answers "what was the last unresolved thing?", and a monotonic stack answers "what is the next greater/smaller element?" — a question hiding inside a surprising number of hard array problems.
Linked Lists
Rarely the hardest problem in a loop, and reliably the one people fumble. Everything here is pointer discipline: a dummy head, a carefully placed temporary, and a drawing on paper before you type.
Recursion & Backtracking
One template — choose, recurse, un-choose — and then the only real skill: pruning, and not generating the same thing twice. Do these in order; the duplicate-handling in the "II" variants is the part interviews test.
Binary Trees
The step with the highest interview frequency of all. Almost every problem is "return something from each subtree and combine" — once you see that shape, most of these become four lines.
Binary Search Trees
A BST is binary search wearing pointers, and inorder traversal of one is a sorted array. Almost every problem here is solved by remembering one of those two sentences.
Heaps & Top-K
Reach for a heap whenever you need the best k of something, or the running median, and cannot afford to sort. Small step, and it makes several otherwise-hard problems routine.
Greedy & Intervals
Intervals are a pattern you can finish in an evening and will be asked about for years: sort by the right endpoint, then sweep. The greedy problems beside them are about proving your choice is safe, not about the code.
Graphs
Grids first, because a grid is a graph you can see. Then traversal, cycles and ordering, and only then the weighted algorithms. Everything before Dijkstra is asked far more often than everything after it.
Dynamic Programming
The step people fear and the step that is most mechanical once you have a process: write the brute-force recursion, memoise it, then make it a table, then shrink the table. Do them in this order and every problem here is the same four steps.
Tries & String Algorithms
A trie is the data structure interviewers reach for when the question involves prefixes, and the matching algorithms below are the ones worth knowing by name even if you are never asked to derive them.
Bit Manipulation & Maths
Short, self-contained, and disproportionately likely to appear as the second question in a screen once the main problem is done. An afternoon here removes a whole category of surprises.
Design & Data Structures
The final step, and the one that most resembles the job. Each problem is a small system: pick the structures, state the complexity of each operation, and defend the trade-off. Say the complexities out loud as you code.
The goal isn’t finishing a sheet.
It’s becoming someone who knows how to think through a new problem.