Roadmap

Data Structures & Algorithms

From first principles to FAANG-ready: master every data structure, algorithm, and pattern interviewers test.

20stages154topics~24hours

Curated from the best, MDN · Kubernetes · AWS · OWASP · Google SRE & more

Core for technical interviews and writing efficient code. Skills: complexity analysis, core data structures, recursion, DP, and greedy algorithms.

The complete path, 7 of 154 topics have lessons here; the other 147 are marked learn anywhere. We won't pretend we cover everything.

Ready to build? See capstone projects

Stage 1 / 20 · 7 topics · 0 lessons

Foundations & Problem-Solving Mindset

The mental models and habits that underpin everything else: how to read a problem, reason about correctness, and pick a language.

What DSA Is & Why Interviews Test ItHow data structures and algorithms map to real engineering and signal problem-solving ability. Tech Interview Handbook

Problem DecompositionBreak a prompt into inputs, outputs, constraints, and edge cases before coding. Tech Interview Handbook

Brute Force First, Then OptimizeAlways establish a correct baseline solution before improving complexity. GeeksforGeeks

Clarify-Plan-Code-Test FrameworkA repeatable interview loop: clarify, design, implement, then verify. Tech Interview Handbook

Choosing an Interview LanguagerecTrade-offs of Python, Java, C++, and JS for speed of expression vs. control. Tech Interview Handbook

Essential Math PrerequisitesrecLogarithms, modular arithmetic, combinatorics, and powers of two. Khan Academy

Invariants & Proving CorrectnessoptionalLoop invariants and informal proofs to argue your solution is right. Wikipedia

Stage 2 / 20 · 8 topics · 1 lessons

Complexity Analysis

How to measure and communicate the cost of an algorithm in time and space, the language every interviewer speaks.

Big-O NotationAsymptotic upper bound for worst-case time and space growth. Big-O Cheat Sheet

Big-Omega & Big-ThetarecLower bounds and tight bounds beyond worst-case Big-O. Wikipedia

Time Complexity AnalysisStart hereCount operations across loops, recursion, and nested structures.

Space Complexity & Auxiliary SpaceDistinguish total memory from extra space used by your algorithm. GeeksforGeeks

Common Complexity ClassesFrom O(1) and O(log n) through O(n!) with concrete examples. Big-O Cheat Sheet

Amortized AnalysisrecAverage cost per operation across a sequence, e.g. dynamic array resize. Wikipedia

Analyzing Recursive ComplexityrecRecurrence relations and the Master Theorem for divide-and-conquer. Wikipedia

Best, Average & Worst CaseWhy average-case matters for hashing and quicksort. Wikipedia

Stage 3 / 20 · 8 topics · 0 lessons

Arrays & Strings

The most-tested data structures. Master contiguous memory, indexing, and the manipulation idioms that appear in nearly every interview.

Static & Dynamic ArraysContiguous storage, O(1) random access, and amortized growth. Wikipedia

Core Array OperationsInsert, delete, search, and traverse with their complexities. GeeksforGeeks

Multidimensional Arrays & MatricesRow/column-major layout and grid traversal patterns. GeeksforGeeks

String FundamentalsImmutability, character encoding, and string-vs-array trade-offs. GeeksforGeeks

Efficient String BuildingAvoid O(n^2) concatenation using builders and joins. Python docs

In-Place ManipulationrecReverse, rotate, and reorder arrays using O(1) extra space. Wikipedia

Prefix Sums & Difference ArraysPrecompute cumulative sums for O(1) range queries. USACO Guide

Subarrays vs Subsequences vs SubstringsrecPrecise definitions that change how you enumerate them. GeeksforGeeks

Stage 4 / 20 · 7 topics · 1 lessons

Hashing & Hash-Based Structures

Constant-time lookup is the single biggest optimization lever in interviews. Understand how hashing works and when it breaks.

Hash FunctionsMapping keys to buckets and properties of a good hash. Wikipedia

Hash Tables / Hash MapsAverage O(1) insert, lookup, and delete via key-value storage.

Collision ResolutionrecChaining vs open addressing and their performance implications. Wikipedia

Hash SetsMembership testing and deduplication in constant time. Python docs

Frequency CountingCount occurrences with maps to solve anagram and majority problems. Python docs

Two-Sum & Complement PatternsTrade space for time by caching seen values. LeetCode

Load Factor & RehashingoptionalWhen tables resize and why worst-case can degrade to O(n). Wikipedia

Stage 5 / 20 · 6 topics · 0 lessons

Two Pointers & Sliding Window

Two of the highest-yield patterns for linear-time array and string solutions. Recognizing them instantly separates strong candidates.

Opposite-Direction Two PointersConverging pointers for sorted-array and palindrome problems. GeeksforGeeks

Same-Direction (Fast/Slow) PointersRead/write pointers for in-place filtering and dedup. GeeksforGeeks

Fixed-Size Sliding WindowMaintain a window of constant length over a sequence. GeeksforGeeks

Variable-Size Sliding WindowExpand and shrink a window to satisfy a constraint. GeeksforGeeks

Sliding Window with Hash MaprecTrack character or element counts inside the window. LeetCode

Merging with Two PointersrecCombine sorted sequences and compute intersections. GeeksforGeeks

Stage 6 / 20 · 8 topics · 2 lessons

Linked Lists

Pointer-based linear structures that teach reference manipulation, and host a family of classic interview tricks.

Singly Linked ListsNodes with next pointers; O(1) head insert, O(n) search.

Doubly & Circular Linked ListsBackward links and circular structures for deques and caches.

Traversal, Insertion & DeletionSplice nodes correctly without losing references. GeeksforGeeks

Reversing a Linked ListIterative and recursive pointer reversal, a must-know. LeetCode

Floyd's Cycle DetectionFast/slow pointers to detect and locate loops. Wikipedia

Dummy / Sentinel NodesrecSimplify edge cases at the head of a list. GeeksforGeeks

Merging & Partitioning ListsrecCombine sorted lists and rearrange by predicate. LeetCode

Linked List vs Array Trade-offsrecWhen pointer chasing beats contiguous memory and vice versa. GeeksforGeeks

Stage 7 / 20 · 7 topics · 0 lessons

Stacks, Queues & Deques

Restricted-access linear structures that model order and recursion. The basis for monotonic-stack and BFS techniques.

Stacks (LIFO)Push/pop semantics and array vs linked implementations. GeeksforGeeks

Queues (FIFO)Enqueue/dequeue and circular-buffer implementation. GeeksforGeeks

Double-Ended QueuesInsert and remove from both ends in O(1). Python docs

Stack ApplicationsBalanced parentheses, expression evaluation, and undo. LeetCode

Monotonic Stack & QueueMaintain ordered elements for next-greater and window-max. GeeksforGeeks

Stack from Queues & Vice VersarecClassic implement-one-with-the-other interview question. LeetCode

Min/Max StackrecSupport O(1) minimum retrieval alongside push/pop. LeetCode

Stage 8 / 20 · 7 topics · 1 lessons

Recursion & Backtracking

The thinking style behind trees, graphs, and combinatorics. Master the call stack, base cases, and systematic search.

Recursion FundamentalsBase cases, recursive cases, and the call stack.

Recursion vs IterationrecConvert between the two and reason about stack depth. GeeksforGeeks

Tail Recursion & Stack LimitsoptionalStack overflow risks and optimization where supported. Wikipedia

The Backtracking TemplateChoose, explore, un-choose to enumerate solution spaces. GeeksforGeeks

Permutations & CombinationsGenerate orderings and selections systematically. GeeksforGeeks

Subsets & Power SetEnumerate all subsets via include/exclude decisions. LeetCode

Pruning & Constraint PropagationrecCut dead branches early, N-Queens, Sudoku, word search. Wikipedia

Stage 9 / 20 · 8 topics · 0 lessons

Sorting Algorithms

Ordering data underpins binary search, greedy, and interval problems. Know the classics cold and when to apply each.

Elementary SortsrecBubble, selection, and insertion sort and their O(n^2) cost. GeeksforGeeks

Merge SortStable divide-and-conquer sort in O(n log n). GeeksforGeeks

Quicksort & PartitioningIn-place sort, pivot choice, and worst-case behavior. GeeksforGeeks

Heap SortrecSort using a binary heap in O(n log n) and O(1) space. GeeksforGeeks

Counting, Radix & Bucket SortrecLinear-time sorting for bounded integer keys. GeeksforGeeks

Stability & Custom ComparatorsPreserve relative order and sort by multiple keys. Wikipedia

QuickselectrecFind the kth smallest in average O(n) via partitioning. Wikipedia

Choosing the Right SortCompare on time, space, stability, and data shape. Big-O Cheat Sheet

Stage 10 / 20 · 7 topics · 0 lessons

Searching & Binary Search

Binary search is the most under-recognized pattern in interviews. Learn the template and the art of searching on the answer.

Linear SearchBaseline O(n) scan and when it is unavoidable. GeeksforGeeks

Binary Search FundamentalsHalve a sorted range to find a target in O(log n). GeeksforGeeks

A Bug-Free Binary Search TemplateHandle bounds, mid overflow, and termination correctly. GeeksforGeeks

Lower & Upper BoundFind first/last positions and insertion points. GeeksforGeeks

Binary Search on the AnswerSearch a monotonic value space, capacity and minimization problems. GeeksforGeeks

Search in Rotated / 2D ArraysrecAdapt binary search to rotated and matrix layouts. LeetCode

Ternary SearchoptionalFind extrema of a unimodal function. cp-algorithms

Stage 11 / 20 · 9 topics · 1 lessons

Trees & Binary Search Trees

Hierarchical structures that dominate the mid-to-hard interview range. Traversals and BST invariants are non-negotiable knowledge.

Tree TerminologyRoot, height, depth, leaves, and ancestors. GeeksforGeeks

Binary TreesTwo-child nodes and complete/full/perfect variants. GeeksforGeeks

DFS Traversals (In/Pre/Post-order)Recursive and iterative depth-first visiting orders. GeeksforGeeks

Level-Order (BFS) TraversalProcess trees breadth-first with a queue. GeeksforGeeks

Binary Search TreesOrdering invariant enabling O(log n) average operations.

BST Insert, Delete & ValidateMaintain the invariant through modifications. GeeksforGeeks

Lowest Common AncestorrecFind the deepest shared ancestor of two nodes. GeeksforGeeks

Tree Construction & SerializationrecBuild from traversals and serialize/deserialize. LeetCode

Tree DFS with Return ValuesrecAggregate subtree results, diameter, max path sum. USACO Guide

Stage 12 / 20 · 7 topics · 0 lessons

Heaps & Priority Queues

The go-to structure for top-k, scheduling, and streaming problems. Know heap mechanics and the patterns they unlock.

Binary HeapsArray-backed complete tree with heap-order property. GeeksforGeeks

Heapify, Push & PopSift-up/down and O(n) build-heap. GeeksforGeeks

Priority QueuesMin/max-heap abstraction for ordered retrieval. Python docs

Top-K Elements PatternMaintain a size-k heap for k largest/smallest/frequent. LeetCode

Two-Heaps (Median) PatternrecBalance min and max heaps to track a running median. LeetCode

K-Way MergerecMerge k sorted lists with a heap of front elements. LeetCode

Indexed / Decrease-Key HeapsoptionalSupport priority updates for Dijkstra and Prim. Wikipedia

Stage 13 / 20 · 12 topics · 0 lessons

Graphs

The richest topic in senior interviews. Master representations, traversals, and the algorithm zoo built on top of them.

Graph RepresentationsAdjacency list vs matrix and their trade-offs. GeeksforGeeks

Graph TypesDirected, weighted, cyclic, and bipartite distinctions. Wikipedia

Breadth-First SearchLayer-by-layer traversal and shortest path in unweighted graphs. GeeksforGeeks

Depth-First SearchExplore deeply for connectivity, paths, and cycles. GeeksforGeeks

Connected Components & Flood FillGroup reachable nodes in grids and graphs. LeetCode

Cycle DetectionrecDetect cycles in directed and undirected graphs. GeeksforGeeks

Topological SortOrder a DAG by dependencies via Kahn's or DFS. GeeksforGeeks

Dijkstra's Shortest PathSingle-source shortest paths with non-negative weights. GeeksforGeeks

Bellman-Ford & Negative EdgesrecShortest paths allowing negative weights and cycle detection. GeeksforGeeks

Floyd-Warshall (All-Pairs)optionalAll-pairs shortest paths via dynamic programming. GeeksforGeeks

Minimum Spanning TreerecPrim's and Kruskal's for least-cost connecting edges. GeeksforGeeks

Grids as Implicit GraphsTreat matrix cells as nodes for traversal problems. USACO Guide

Stage 14 / 20 · 7 topics · 0 lessons

Advanced Trees & Disjoint Sets

Specialized structures that show up in hard problems and system-flavored questions. Strong differentiators at senior levels.

Tries (Prefix Trees)Character-indexed trees for prefix and word lookups. GeeksforGeeks

Union-Find (Disjoint Set)Near-constant connectivity with union by rank and path compression. GeeksforGeeks

Segment TreesrecLogarithmic range queries and point updates. cp-algorithms

Fenwick / Binary Indexed TreerecCompact prefix-sum queries with updates. cp-algorithms

Self-Balancing BSTsoptionalAVL and red-black rotations guaranteeing O(log n). Wikipedia

N-ary Trees & Tree DPoptionalGeneralize beyond binary and aggregate over children. GeeksforGeeks

LRU / LFU Cache DesignrecCombine hash map and linked list for O(1) eviction. LeetCode

Stage 15 / 20 · 6 topics · 0 lessons

Greedy Algorithms

Locally optimal choices that sometimes yield global optimums. Learn to spot when greedy works, and prove it.

The Greedy ParadigmMake the best immediate choice and never reconsider. GeeksforGeeks

Proving Greedy CorrectnessrecExchange arguments and the greedy-choice property. Wikipedia

Interval Scheduling & MergingSort-then-sweep for overlaps, meetings, and rooms. GeeksforGeeks

Classic Greedy ProblemsJump game, gas station, and activity selection. GeeksforGeeks

Huffman CodingoptionalGreedy optimal prefix codes via a min-heap. GeeksforGeeks

Greedy vs DPrecRecognize when greedy fails and DP is required. GeeksforGeeks

Stage 16 / 20 · 13 topics · 0 lessons

Dynamic Programming

The make-or-break topic for hard interviews. Build intuition for states, transitions, and the canonical DP families.

DP FundamentalsOptimal substructure and overlapping subproblems. GeeksforGeeks

Top-Down MemoizationCache recursive results to avoid recomputation. GeeksforGeeks

Bottom-Up TabulationFill a DP table iteratively from base cases. GeeksforGeeks

Defining State & TransitionsThe core skill: identify what uniquely describes a subproblem. USACO Guide

1D DPFibonacci, climbing stairs, house robber, and decode ways. LeetCode

Knapsack Family0/1, unbounded, and subset-sum partition variants. GeeksforGeeks

Sequence DP (LCS, Edit Distance)Two-string alignment and transformation problems. GeeksforGeeks

Longest Increasing SubsequencerecO(n^2) DP and the O(n log n) patience approach. GeeksforGeeks

Grid & Path DPUnique paths, minimum path sum, and 2D state. LeetCode

Interval DPrecMatrix-chain, burst balloons, and range partitioning. USACO Guide

DP on Trees & DAGsrecCombine subproblem results over hierarchical structures. USACO Guide

Bitmask DPoptionalEncode subsets in integers for TSP-style problems. USACO Guide

Space OptimizationrecReduce DP tables to rolling rows or single arrays. GeeksforGeeks

Stage 17 / 20 · 7 topics · 0 lessons

Bit Manipulation & Math

Low-level tricks and number theory that produce elegant O(1) solutions and occasionally make-or-break a problem.

Bitwise OperatorsAND, OR, XOR, NOT, and shifts as building blocks. GeeksforGeeks

Common Bit TricksCheck, set, clear, toggle bits and isolate the lowest set bit. Stanford Bit Hacks

XOR PatternsrecFind the unique number and missing/duplicate elements. LeetCode

Bit Counting & MasksrecPopulation count and using masks as compact sets. Wikipedia

Number Theory EssentialsrecGCD/LCM, primes, sieve, and modular arithmetic. cp-algorithms

Fast ExponentiationoptionalCompute powers in O(log n) via binary exponentiation. cp-algorithms

Integer Overflow & Edge CasesrecHandle bounds, negatives, and language-specific widths. Wikipedia

Stage 18 / 20 · 6 topics · 1 lessons

Intervals & Object-Oriented Design

Frequently tested standalone topics: interval reasoning and translating requirements into clean data-structure-backed designs.

Interval Representation & SortingModel ranges and sort by start or end for sweeps. GeeksforGeeks

Merge & Insert IntervalsCombine overlapping ranges and insert new ones. LeetCode

Sweep Line & Event CountingrecProcess start/end events to find overlaps and peaks. USACO Guide

Designing Composite Data StructuresCombine primitives to meet O(1)/O(log n) requirements. GeeksforGeeks

Iterators & Stream DesignrecImplement hasNext/next and flatten nested structures. Refactoring Guru

Design Problems (Rate Limiter, Hit Counter)optionalApply DSA to small system-flavored design prompts.

Stage 19 / 20 · 6 topics · 0 lessons

Advanced String Algorithms

Pattern matching and string-specific algorithms that surface in harder rounds and at companies with heavy text workloads.

Naive String MatchingBaseline substring search and its O(nm) cost. GeeksforGeeks

KMP AlgorithmrecLinear-time matching using the prefix-function table. GeeksforGeeks

Rabin-Karp & Rolling HashrecHash-based matching and substring fingerprinting. GeeksforGeeks

Palindrome TechniquesrecExpand-around-center and Manacher's algorithm. LeetCode

Anagrams & Canonical FormsGroup and detect anagrams via sorting or counts. LeetCode

Trie-Based String ProblemsrecWord search, autocomplete, and prefix aggregation. LeetCode

Stage 20 / 20 · 8 topics · 0 lessons

Interview Patterns & Meta-Skills

The synthesis layer: recognizing which pattern a problem hides, and the communication and testing habits that win offers.

Pattern RecognitionMap problem signals to the right technique fast. Tech Interview Handbook

Estimating Target Complexity from ConstraintsInfer the intended approach from input bounds. USACO Guide

Edge Cases & Test DesignEmpty, single, duplicate, overflow, and boundary inputs. Tech Interview Handbook

Communicating While CodingThink aloud, justify trade-offs, and handle hints. Google SRE Book

Dry-Running & DebuggingrecTrace code by hand to catch bugs before running. Tech Interview Handbook

Iterative OptimizationrecMove from brute force to optimal through bottleneck analysis. Tech Interview Handbook

Spaced Practice & MocksrecStructure a study plan with timed problems and review. Tech Interview Handbook

Articulating Trade-offsoptionalDiscuss time/space and readability trade-offs convincingly. Tech Interview Handbook

You're job-ready.

Clear every stage, earn the certificate, and walk into interviews prepared. The complete path, nothing hidden, no gaps.

Destination reached