DSA Interview Playbook
A structured DSA series that prioritizes the highest-value interview patterns first and turns the checklist into a practical study plan
Why This Series Exists
Data structures and algorithms usually feel overwhelming for one reason: people try to memorize isolated tricks instead of learning reusable patterns.
This series turns your checklist into a practical blog-style study roadmap:
- focus first on the highest-frequency interview patterns
- learn the intuition before the code
- practice the recognition signals that tell you which algorithm to use
- revise with compact dry runs, complexity notes, and common mistakes
- organize everything topic-wise, with separate files for individual algorithms and pattern families
How to Use These Blogs
Read each article in this order:
- Start with the intuition
- Study the step-by-step flow
- Walk through the dry run
- Reproduce the C++ code from memory
- Solve 2 to 4 problems immediately after reading
Priority Roadmap
If you want the highest return first, follow this order:
- Arrays, sliding windows, prefix sums, and binary search
- Linked lists, stacks, queues, BFS, and heaps
- Trees, graphs, DFS, Dijkstra, and Union-Find
- Dynamic programming and greedy patterns
- Advanced strings, bit manipulation, math, and range-query data structures
DSA Series
Arrays and Binary Search
Two pointers, sliding windows, prefix sums, Kadane, and the binary search family
Linked List Patterns
Reverse, merge, fast-slow pointers, nth-from-end, k-group reversal, and random pointers
Stack, Queue, and Heap Patterns
Valid parentheses, monotonic stack, BFS, deque patterns, heaps, top-k, and LRU thinking
Recursion, Backtracking, and Trees
Subsets, permutations, N-Queens, traversals, diameter, LCA, serialization, and BSTs
Graphs and Union-Find
DFS, cycle detection, topological sort, bipartite graphs, Dijkstra, Bellman-Ford, Kruskal, and Prim
Dynamic Programming and Greedy
Fibonacci, knapsack, LIS, LCS, grids, trees, interval scheduling, and jump game
Advanced Strings, Bits, Math, and Range Queries
KMP, Z algorithm, XOR tricks, sieve, fast power, segment tree, and Fenwick tree
What To Master First
These are the patterns that show up again and again in interviews:
- Two Pointer
- Sliding Window
- Prefix Sum
- Kadane's Algorithm
- Binary Search
- Reverse Linked List
- Fast & Slow Pointer
- Valid Parentheses
- Monotonic Stack
- BFS
- Heap / Top K
- DFS and Topological Sort
- Dijkstra
- Union-Find
- Fibonacci-style DP
- Knapsack
- LIS
- LCS
- Activity Selection
- Jump Game
Problem-Solving Checklist
Before coding, ask yourself:
- Is the input sorted or can it become sorted?
- Is the problem asking about a subarray or substring?
- Is there a range sum or repeated query pattern?
- Is the state coming from previous choices?
- Is this really a graph in disguise?
- Do I need the minimum/maximum quickly over a changing set?
- Can I define a monotonic answer space and binary-search it?
Practice Advice
- Spend most of your time on starred topics until they feel automatic
- Solve the same pattern in multiple disguises
- After every problem, write one sentence:
Why was this the right pattern? - Keep one revision sheet with only:
- recognition hints
- core loop
- complexity
- common bugs
What This Series Covers Beyond The Starred List
The blogs go deep on the core interview patterns first, then connect them to nearby ideas like:
- difference array after prefix sums
- search in rotated array after binary search
- multi-source BFS after normal BFS
- Kruskal and Prim after Union-Find and heaps
- space-optimized DP after standard DP
- Fenwick tree after prefix-thinking becomes too slow
If you can explain the intuition, trace a dry run, and write the core version from memory, you are already far ahead of most interview prep.