Data Structures & Algorithms

What an SDE2 DSA round actually tests, the Big-O cheat sheet, the 'input size → expected complexity' trick, and a pattern-recognition table to map a problem to a technique fast.

The problem statement is full of clues that name the right pattern. Learn the decoder table and the 7-step routine, then practice the thinking itself on guided walkthroughs.

Contiguous memory, O(1) indexing vs O(n) insertion, dynamic arrays, and why strings are arrays with rules.

Nodes and pointers, O(1) insertion vs O(n) access, dummy heads, and the in-place reversal every interviewer asks.

LIFO and FIFO — the two access disciplines behind undo, the call stack, BFS, and every task queue you'll ever deploy.

How dicts actually work — hash functions, buckets, collisions, resizing — and why O(1) lookup powers half of all interview solutions.

Hierarchy as a data structure — tree vocabulary, the four traversals, binary search trees, and why balance is everything.

Two patterns that show up constantly: a heap for top-K / streaming / merging, and sort-then-sweep for interval problems.

Prefix trees — where the path IS the key. The structure behind autocomplete, spell-check and prefix search in O(word length).

Everything about graphs from scratch — representation, BFS, DFS, cycle detection, topological sort, Dijkstra, Bellman-Ford, Floyd-Warshall, Prim, Kruskal, SCC, bridges, articulation points, and every pattern you need to crack any graph interview.

Disjoint sets in ~10 lines — union by rank, path compression, and the 'are these connected?' questions it wins instantly.

Merge sort, quicksort, heap sort and when to use each — plus the searching ladder from linear scan to binary search, and what interviewers actually test.

A template that never has off-by-one bugs, plus the SDE2-level skill: binary-searching the answer space for 'minimum X that works' problems.

Opposite-end, fast/slow, and partition variants — replace nested loops on sorted/linked data with a single O(n) pass.

Turn an O(n·k) recompute-from-scratch loop into O(n) by maintaining a moving range and updating it incrementally.

The 'now optimize it for a stream with limited memory' follow-up: one-pass algorithms and sketches — top-K with a heap, reservoir sampling, Boyer-Moore majority, Count-Min, Bloom filters, HyperLogLog, running median, and external sort for data bigger than RAM.

The operator alphabet, the handful of identities that actually win interviews (XOR cancellation, x & (x-1), x & -x), and the bitmask bridge into subset DP — leveled from SDE-1 warm-ups to Staff-level XOR puzzles.

The math interviews actually test: GCD/Euclid, modular arithmetic and the 1e9+7 convention, fast exponentiation, the sieve and primality, nCr mod p, and the overflow traps — the toolkit behind half of LeetCode's medium math tags.

Try a choice, check it's still legal, go deeper — and when you hit a dead end, undo and try the next option. The pattern behind subsets, permutations and every constraint puzzle.

Take the locally best choice and never look back — when that's provably optimal, when it's a trap, and the interval/jump/exchange classics.

How to recognize DP, the five-step recipe (state, transition, base, order, answer), memoization vs tabulation, and the classic problem families.

The six families that cover ~90% of DP interviews — knapsack, LIS, LCS, grid, interval and bitmask — each with its state, recurrence and tell.

Past BFS/DFS: every weighted-graph algorithm you need — Dijkstra, Bellman-Ford, Floyd-Warshall, Kruskal, Prim — each explained with Why → How → When → Code in Python, Java, and C++. Includes a decision table for picking the right algorithm under interview pressure.

Range queries on changing data: why prefix sums break, how segment trees answer any range in O(log n), and the Fenwick tree's beautiful bit trick.

Finding patterns in text fast: rolling hashes and Rabin-Karp, KMP's failure function demystified, and when to just call the library.

The multithreading round that isn't really DSA: locks, semaphores and condition variables, then the classics — producer-consumer, readers-writers, dining philosophers — plus the deadlock conditions and how to avoid them.

A curated set of high-frequency problems grouped by pattern. Each is a flashcard: read the prompt, decide your approach, then reveal the optimal idea and complexity.

The famous list, reorganized by pattern with the key insight for each problem — so you learn 15 ideas, not 75 answers.

The interview funnel (DSA → LLD → HLD) mapped to each company's house style and recently-reported question patterns — so you prep for the round you'll actually get, not a generic list.

Timed drill formats, the UMPIRE protocol, a self-scoring rubric, and how to practice the talking — because the interview tests narration, not just code.

The real algorithms inside LandAI, StockVision and StockStump — the DSA primitive under each, its complexity, and how to explain it when an interviewer drills into your project.