Learning track · 27 concepts
DSA & Implementation
Fast, clean implementation ability: arrays, graphs, trees, dynamic programming, and the core algorithmic patterns.
What mastery looks like
This track contains 27 connected concepts rather than an unordered reading list. Mastery means you can move from vocabulary to mechanisms, predict how the system behaves under pressure, and support a design decision with code, measurements, or a failure-recovery exercise. For DSA & Implementation, use the track description as the boundary: learn enough detail to reason clearly about fast, clean implementation ability: arrays, graphs, trees, dynamic programming, and the core algorithmic patterns.
A useful explanation names the state involved, the operation that changes it, the resource or safety constraint, and the observable signal that tells you whether the mechanism works. Avoid stopping at product names. Compare at least two approaches, state what each optimizes, and identify what breaks first as scale, concurrency, latency, or uncertainty increases.
Suggested study sequence
Start with Arrays & Hashing, Stack, Linked List, Complexity Analysis to establish the basic vocabulary. Continue through the core concepts by alternating explanation with an executable drill. Treat Backtracking, Graphs, Shortest Path, 1D DP as integration work: they should combine earlier mechanisms rather than introduce disconnected facts.
At the end of each session, record one decision you can now make, one failure mode you can now predict, and one unanswered question. Revisit that question through the linked primary sources, then prove the answer in the Playground or a real repository. The track is complete when you can transfer the reasoning to an unfamiliar system, not when every page has been opened.
Roadmaps
Concepts in this track
intro
Arrays & Hashing
Hash maps, sets, frequency counting.
core
Two Pointers
Converging/diverging pointer scans.
core
Sliding Window
Variable/fixed window over sequences.
intro
Stack
LIFO, parsing, monotonic stack.
core
Binary Search
Halving sorted search space, predicate search.
intro
Linked List
Pointer manipulation, fast/slow, reversal.
core
Trees
Binary trees, BSTs, DFS/BFS.
core
Trie
Prefix trees.
core
Heap / Priority Queue
Top-k, k-way merge, scheduling.
advanced
Backtracking
DFS with state restoration, pruning.
advanced
Graphs
BFS/DFS, topo sort, union-find.
advanced
Shortest Path
Dijkstra, Bellman-Ford, A*.
core
Union-Find
Disjoint set, path compression.
advanced
1D DP
Linear state recurrences.
advanced
2D DP
Grid DP, edit distance, knapsack.
core
Greedy
Local-optimal-as-global proofs.
core
Intervals
Merge, overlap, sweep line.
core
Math & Geometry
Number theory, modular, geometry.
core
Bit Manipulation
Bitwise ops, masks, XOR tricks.
intro
Complexity Analysis
Big-O, amortised cost, and space complexity — how to argue a bound before writing code.
core
Sorting
Comparison sorts, stability, in-place versus extra space, and when a linear-time sort is available.
core
Prefix Sums
Precomputed cumulative arrays that turn repeated range queries into O(1) lookups.
core
Monotonic Stack
A stack kept sorted so each element is pushed and popped once, answering next-greater questions in O(n).
core
String Matching
Finding a pattern in text in linear time — KMP's failure function and Rabin-Karp's rolling hash.
core
Minimum Spanning Tree
Kruskal and Prim — connecting every node at least total cost.
intro
Recursion & Induction
Writing recursion you can trust, and solving the recurrence it produces.
core
Quickselect
Finding the k-th smallest in expected O(n) by recursing into only one partition.