roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Solve interview problems on data structures and algorithms, from complexity analysis to recurring patterns. Covers core structures, trees and graphs, sorting, and the algorithmic paradigms.
833 of 833 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 833 new. 0 cut, outside your plan.
Data structures and algorithms are tested in the coding round, the part of the loop most software engineering roles share whatever the stack: an online assessment or a phone screen, then one to three live problems later on, in a shared editor or on a whiteboard. What changes with level is how much the interviewer expects around the code.
The problems are rarely exotic; the follow-ups are where they get hard. Why does appending to a dynamic array count as constant time when some appends copy the whole array? What does a hash map lookup cost once every key lands in one bucket? Why does Dijkstra's algorithm return wrong distances when an edge weight is negative, and why does a sliding window stop working once the array can hold negative numbers? The limits in the statement are part of the question too: with a hundred thousand elements, a quadratic scan is ruled out before you write it.
Early in the level range, fluency means a correct baseline said aloud, then an improvement with its cost named. Further up, interviewers want the argument behind the choice: the exchange argument that makes a greedy step safe, the state and recurrence behind a dynamic programming table, the invariant a binary search loop keeps, and the input that breaks the code, found before anyone runs it.
Complexity stands alone at the top because every later module is priced in it. Amortized analysis is what lets a resizing array or a hash table claim constant time, and reading the input limits back into an acceptable cost is a habit the rest of the plan leans on.
The core structures run from what memory gives you to what you build on it. Arrays and strings index cheaply and insert expensively; linked lists reverse that trade and drill the pointer handling later modules take for granted; stacks and queues are access rules laid over either. Hashing closes the stretch, because a hash set is the first tool that turns a nested-loop baseline into one pass.
Then the plan leaves straight lines. Trees make recursion unavoidable and give the ordered operations a hash table lacks. Heaps come before graphs because a priority queue drives Dijkstra's shortest paths and Prim's spanning tree, and graph traversal is largely tree traversal with a visited set added.
Sorting arrives after the structures, so heapsort reads as a use of the heap and the module can spend its time on stability, lower bounds and what standard libraries actually run. Binary search follows because it needs ordered input, then reaches past arrays: searching on the answer halves a range of candidate values, such as the smallest capacity that ships everything in time.
The paradigms turn from structures to ways of building a solution. Recursion and backtracking lead, with divide and conquer naming what merge sort and quicksort already did. Dynamic programming is recursion with overlapping subproblems remembered, and greedy algorithms follow it because the real question is when a greedy choice can replace the table.
The close changes direction. Problem patterns such as two pointers are recurring shapes of the structures above, placed late because spotting a cue in a statement requires knowing what it might point to. Bit manipulation and math adds tools that cut across modules, from bitmasks standing in for sets to overflow. Problem-solving strategy ends on the round itself.
Read the plan's last module first. The [solving method](/topics/found-dsa-problem-solving-method) is short and shapes how every later problem should be practiced: clarify the task, state a baseline, improve it against the limits, then test by hand. Screens usually draw on arrays, strings, hashing and the patterns built on them, so with two weeks or less, practice by frequency with importance narrowed to must know; graphs and dynamic programming then reach you only through the questions that survive the cut. The by topics study order earns its place over months, since dynamic programming assumes the recursion the tree module drilled. Either way, write problems out in the language you will interview in: the page drills the reasoning, and the typing still needs a timer. Engineers returning after years away usually lose speed rather than knowledge: complexity, hashing and sorting come back quickly, while backtracking, dynamic programming state design and the rarer graph algorithms need repetition. The plan stays inside the coding round. Designing a service that holds up under load is a separate round that from middle level up often weighs as much, and the [System Design roadmap](/roadmaps/system-design) prepares for it.
Read the plan's last module first. The solving method is short and shapes how every later problem should be practiced: clarify the task, state a baseline, improve it against the limits, then test by hand.
Screens usually draw on arrays, strings, hashing and the patterns built on them, so with two weeks or less, practice by frequency with importance narrowed to must know; graphs and dynamic programming then reach you only through the questions that survive the cut. The by topics study order earns its place over months, since dynamic programming assumes the recursion the tree module drilled. Either way, write problems out in the language you will interview in: the page drills the reasoning, and the typing still needs a timer.
Engineers returning after years away usually lose speed rather than knowledge: complexity, hashing and sorting come back quickly, while backtracking, dynamic programming state design and the rarer graph algorithms need repetition.
The plan stays inside the coding round. Designing a service that holds up under load is a separate round that from middle level up often weighs as much, and the System Design roadmap prepares for it.