Skip to content

The DSA roadmap.In the order ideas build.

20 stops, 422 LeetCode problems. Two a day gets you to the end in about 7 months.

Start at stop 1 Solve on LeetCode. It's ticked here by itself.
  • Groundwork6 stops · 130
  • Structures6 stops · 130
  • Graphs & choices4 stops · 87
  • Mastery4 stops · 75

PHASE 1Groundwork

  1. Stop 1

    Foundations

    Big-O, complexity analysis and the basic math every later topic leans on.

    5 problems
    • Complexity Analysis
    • Simulation
    • Digit Manipulation
  2. Stop 2

    Arrays, Strings & Hashing

    Hash maps, frequency counting and prefix sums: the tools behind a third of all interview questions.

    35 problems
    • Hash Map Lookup
    • Hash Set
    • Frequency Count
  3. Stop 3

    Two Pointers

    Two indices moving through data to replace nested loops with a single pass.

    20 problems
    • Opposite Ends
    • Same Direction (Read/Write)
    • Sort + Two Pointers
  4. Stop 4

    Sliding Window

    Maintain a window over a sequence and update it incrementally instead of recomputing.

    20 problems
    • Fixed-size Window
    • Variable Window (Shrink When Invalid)
    • Window + Frequency Map
  5. Stop 5

    Stack & Monotonic Stack

    Last-in-first-out processing for parsing, undo-style logic and 'next greater' questions.

    25 problems
    • Matching / Parsing
    • Stack Simulation
    • Monotonic Stack
  6. Stop 6

    Binary Search

    Halve the search space each step, on arrays and, more powerfully, on the answer itself.

    25 problems
    • Classic Binary Search
    • Lower / Upper Bound
    • Rotated Sorted Array

PHASE 2Structures

  1. Stop 7

    Linked List

    Pointer manipulation: reversal, fast & slow pointers, merging and cache design.

    25 problems
    • Dummy Head
    • In-place Reversal
    • Fast & Slow Pointers
  2. Stop 8

    Recursion & Backtracking

    Think recursively, then explore every choice and undo it: subsets, permutations and search.

    25 problems
    • Recursion Basics
    • Divide & Conquer
    • Subsets (Include / Exclude)
  3. Stop 9

    Binary Trees

    Recursive DFS, level-order BFS, path problems, construction and lowest common ancestors.

    35 problems
    • DFS Traversals (Pre / In / Post)
    • BFS Level Order
    • Bottom-up DFS (Return Values)
  4. Stop 10

    Binary Search Trees

    Use the ordering invariant: inorder is sorted, and every step discards a subtree.

    15 problems
    • BST Invariant (Bounds)
    • Inorder = Sorted
    • BST Insert / Delete
  5. Stop 11

    Heaps / Priority Queue

    Always know the smallest or largest item in O(1): top-K, k-way merge, scheduling and running medians.

    20 problems
    • Top-K with a Size-K Heap
    • K-way Merge
    • Two Heaps
  6. Stop 12

    Tries

    Prefix trees for autocomplete, dictionary search and bitwise XOR tricks.

    10 problems
    • Prefix Tree
    • Trie + DFS (Wildcards)
    • Trie + Backtracking

Interview-ready.

Every pattern a coding round asks for, practised.

Start the route, free