A structured path for coding interviews at OpenAI, Anthropic, Google, Sierra, and Ramp. The plan uses CLRS, Jeff Erickson, and Skiena as references, with NeetCode and LeetCode as the real practice engine.
Review complexity, core data structures, recursion, and implementation mechanics in your interview language.
Learn one topic at a time, then drill the related NeetCode and LeetCode sets until the pattern becomes recognizable.
Shift from learning to performance: timed sets, mock interviews, communicating tradeoffs, and re-solving misses.
Treat this as a default path. If a topic is already easy, compress it and spend the saved time on timed practice.
Logged on June 21. Week 1 is complete. Phase 1 continues in Week 2 with the remaining foundation items plus binary search, sorting, intervals, and ordered map concepts.
Time, space, nested loops, recursion trees, common operation costs.
Indexing, slicing, resizing intuition, in-place updates, parsing.
Frequency counts, membership, deduplication, grouping.
LIFO/FIFO, BFS queues, monotonic stacks, monotonic deques, expression structure.
Pointers, reversal, fast/slow technique, cycle detection.
Min-heap, max-heap, top K, scheduling, streaming medians.
Search, insert, delete, inorder traversal, predecessor/successor, range-query intuition.
Base cases, recursive state, call stack, tree-shaped execution.
Empty input, one item, duplicates, negative values, cycles, disconnected inputs.
Week 1 focuses on the high-priority core through Binary Search Tree. The remaining structures are useful, but they belong in later topic weeks rather than the initial foundation sprint.
| Structure | Core Operations | Interview Use | Priority |
|---|---|---|---|
| Array / Dynamic Array / String | Index, scan, resize intuition, slice, mutate in place. | Two pointers, sliding window, prefix sums, parsing, sorting. | High |
| Hash Map / Hash Set | Average O(1) lookup, insert, delete; understand hashing and collisions. | Membership, frequency maps, grouping, deduplication, value-to-index metadata. | High |
| Stack | Push, pop, peek; LIFO state. | DFS, parentheses, monotonic stack, expression parsing, backtracking state. | High |
| Queue / Deque | FIFO operations; push and pop from both ends for deque. | BFS, level order traversal, sliding window max, monotonic queue, 0-1 BFS. | High |
| Linked List | Singly vs doubly linked, pointer rewiring, dummy nodes. | Reverse, merge, fast/slow pointers, cycle detection, LRU cache internals. | High |
| Heap / Priority Queue | Push O(log n), pop O(log n), peek O(1), heapify O(n). | Top K, scheduling, merge K sorted lists, Dijkstra, two-heap median. | High |
| Binary Search Tree | Search, insert, delete, min/max, predecessor/successor, inorder traversal. | Ordered set/map intuition, range queries, sorted traversal. Plain BST can degrade to O(n). | High |
| Balanced Ordered Map / Set | O(log n) insert/delete/search; predecessor/successor and range operations. | Intervals, sweep line, scheduling, closest value so far. Know the API even if your language hides it. | Medium |
| Trie | Insert/search by character path; each node represents a prefix. | Autocomplete, prefix search, wildcard dictionaries, Word Search II. | Medium |
| Union-Find / DSU | Find, union, path compression, union by rank or size. | Connectivity, components, undirected cycle detection, account/email grouping. | Medium |
| LRU Cache Composite | Hash map plus doubly linked list for O(1) get, put, and eviction. | Classic design-data-structure problem; useful for practical coding rounds. | Medium |
| Segment Tree / Fenwick Tree | O(log n) range queries and point updates. | Harder range-query problems, inversion counts, dynamic prefix sums. | Lower |
| Bloom Filter / Skip List | Bloom filter: space-efficient membership with false positives. Skip list: randomized ordered structure. | Mostly systems-flavored knowledge; rarely needed for coding rounds. | Lower |
| Topic | What to Learn | Practice Focus | Priority |
|---|---|---|---|
| Arrays and Hashing | Frequency maps, sets, grouping, prefix sums, in-place updates. | Two Sum, Group Anagrams, Product Except Self, Subarray Sum. | High |
| Iteration Patterns | Two pointers, sliding window, fast/slow pointers, prefix/suffix scans. | Longest substring, container water, sorted pair sums, cycle detection. | High |
| Stacks | Monotonic stack, nested structure, parsing, undo-style state. | Valid Parentheses, Daily Temperatures, Evaluate RPN. | High |
| Binary Search | Lower bound, upper bound, answer-space search, sorted invariants. | Search Rotated Array, Koko Eating Bananas, Median variants. | High |
| Sorting and Intervals | Comparator logic, merge intervals, sweep line, scheduling. | Merge Intervals, Meeting Rooms, Insert Interval, Non-overlap intervals. | High |
| Trees and BSTs | DFS, BFS, traversal, subtree return values, LCA, BST invariants, ordered set/map intuition. | Max Depth, Diameter, Validate BST, LCA, Serialize Tree. | High |
| Backtracking | Choice trees, constraints, pruning, duplicate handling. | Subsets, Permutations, Combination Sum, Word Search. | Medium |
| Graphs and Grids | Adjacency lists, BFS/DFS, components, cycles, multi-source BFS. | Number of Islands, Clone Graph, Rotting Oranges, Course Schedule. | High |
| Heaps | Priority queues, min/max heap behavior, top K, merging streams, scheduling. | Kth Largest, Merge K Lists, Task Scheduler, Find Median Stream. | High |
| Dynamic Programming | State definition, recurrence, base cases, memoization, tabulation. | Climbing Stairs, House Robber, Coin Change, LIS, LCS. | High |
| Greedy | Local choice arguments, exchange reasoning, sorting plus greedy. | Jump Game, Gas Station, Partition Labels, scheduling problems. | Medium |
| Union Find | Path compression, union by rank, connectivity. | Redundant Connection, Number of Components, Accounts Merge. | Medium |
| Tries | Prefix trees, dictionary search, combining trie + DFS. | Implement Trie, Word Dictionary, Word Search II. | Medium |
| Bit Manipulation | XOR, masks, bit counts, subset generation. | Single Number, Counting Bits, Missing Number, Subsets with masks. | Lower |
| Design-Style Coding | APIs, state modeling, invariants, tests, readable object design. | LRU Cache, TimeMap, Rate Limiter, Scheduler, In-memory store. | High |
Use as a reference when you need rigor: asymptotic analysis, heaps, sorting, dynamic programming, graph algorithms.
Do not read cover to cover for interview prep. It is the encyclopedia, not the daily workout.Use for conceptual clarity and language-neutral explanations, especially recursion, dynamic programming, graph traversal, and shortest paths.
Best when you want the idea to click without Java-specific framing.Use for problem recognition, design instincts, and the catalog of algorithmic problems.
Great before and after practice sets: first to orient, then to deepen.Main roadmap. Work by topic, starting with NeetCode 150. Watch explanations only after a serious attempt.
Primary use: pattern acquisition.Main problem bank. Use topic lists, Top Interview 150, company tags when available, and timed random review.
Primary use: volume, timing, and variation.Optional but excellent for dense practice in your interview language. Add it if LeetCode solutions start feeling too pattern-memorized.
Primary use: sharper implementation and follow-up questions.Read one focused section from CLRS, Erickson, or Skiena. Take notes only on invariants, templates, and common mistakes.
Solve 3-5 topic problems. Spend 25-35 minutes per problem before checking hints or editorials.
Maintain an error log. Re-solve missed problems after 3 days, 1 week, and 3 weeks.
Once weekly, do a 45-minute interview simulation: clarify, code, test, and explain complexity out loud.
Every other week, implement a structure or system from scratch: heap, LRU cache, rate limiter, scheduler, or in-memory store.
In weeks 7-9, do one live mock weekly. The goal is calm communication under pressure.