structured learning path

DSA Mastery
Roadmap

Data Structures & Algorithms — from zero to expert, one concept at a time.

Phase 01Foundations~2–3 weeks

Big-O Notation

Time & space complexity

Arrays

Indexing, traversal, ops

Strings

Manipulation, patterns

Recursion

Base case, call stack

Math Basics

Modulo, primes, GCD

Bit Manipulation

AND, OR, XOR, shifts

Tip: Pick one language and stick with it. Understand how arrays work in memory before moving on.

Phase 02Core Data Structures~3–4 weeks

Linked Lists

Singly, doubly, circular

Stacks

LIFO, monotonic stack

Queues

FIFO, deque, circular

Hash Tables

Hashing, collision, load

Binary Trees

BST, traversals, height

Heaps / Priority Q

Min/max heap, heapify

Tip: Implement each structure from scratch at least once. Understanding internals beats memorizing APIs.

Phase 03Core Algorithms~4–5 weeks

Binary Search

Variants, search space

Two Pointers

Opposite ends, fast/slow

Sliding Window

Fixed & variable size

Sorting Algorithms

Merge, quick, heap, radix

BFS

Level-order, shortest path

DFS

Preorder, paths, backtrack

Prefix Sums

Range queries, 2D prefix

Divide & Conquer

Merge sort, master theorem

Tip: Solve 3–5 LeetCode medium problems per topic before moving on. Pattern recognition is the goal.

Phase 04Advanced Data Structures~3–4 weeks

Graphs

Adjacency list/matrix

Tries (Prefix Trees)

Insert, search, autocomplete

Segment Trees

Range query & update

Union-Find (DSU)

Path compression, rank

Fenwick Tree (BIT)

Point update, prefix sum

AVL / Red-Black

Self-balancing BSTs

Sparse Tables

Range minimum queries

Monotonic Structures

Deque, stack variants

Tip: Don't rush this phase. Each structure unlocks a whole class of problems — depth matters more than breadth here.

Phase 05Advanced Algorithms~5–6 weeks

Dynamic Programming

Memoization, tabulation

DP Patterns

Knapsack, LCS, LIS, grid

Greedy Algorithms

Interval, activity selection

Backtracking

Permutations, N-Queens

Graph Algorithms

Dijkstra, Bellman-Ford

Topological Sort

Kahn's, DFS-based

MST Algorithms

Kruskal, Prim

String Algorithms

KMP, Z-algo, Rabin-Karp

Tip: DP is the hardest topic for most people. Start with recognizing overlapping subproblems, then practice identifying state transitions.

Phase 06Expert & Competitiveongoing

Advanced DP

Bitmask, digit, tree DP

Advanced Graphs

SCC, bridges, articulation

Network Flow

Max-flow, bipartite match

Heavy-Light Decomp

Tree path queries

Suffix Arrays

SA-IS, LCP, suffix automata

Geometry

Convex hull, line sweep

Game Theory

Nim, Sprague-Grundy

FFT / NTT

Polynomial multiplication

Tip: At this level, participate in Codeforces, AtCoder, or LeetCode contests regularly. Speed and problem recognition matter as much as knowledge.

Foundations

Core Data Structures

Core Algorithms

Advanced Structures

Advanced Algorithms

Expert / Competitive