Here is something I’d tell anyone starting their first round of technical interview prep: you do not need to understand red-black trees to pass a software engineering interview at 97% of companies. I’ve been through this process multiple times and helped people on both sides of it. The list of truly necessary structures is shorter than most guides want you to believe.
That said, knowing the right 8 deeply is harder than knowing 20 superficially. That’s the actual challenge.
Why 8 structures cover most of what interviewers ask
Most coding interviews draw from a narrow, well-established set of problems. Companies reuse them because writing original interview problems is time-consuming and risky (edge cases, unclear prompts, interviewer-to-interviewer variance). The structures that show up repeatedly aren’t random. They’re the ones that:
- Have clear, testable time and space complexity tradeoffs
- Appear in enough real engineering contexts that knowing them signals practical skill
- Are complex enough to reveal how someone thinks under pressure without requiring domain-specific knowledge
The 8 structures that meet all three criteria: arrays, hash tables, linked lists, stacks and queues, binary trees, heaps, graphs, and tries.
The complexity table you’ll actually refer back to
| Structure | Access | Search | Insert | Delete |
|---|---|---|---|---|
| Array | O(1) | O(n) | O(n) | O(n) |
| Hash Table | O(1) avg | O(1) avg | O(1) avg | O(1) avg |
| Linked List | O(n) | O(n) | O(1) at head | O(1) with pointer |
| Stack / Queue | O(n) | O(n) | O(1) | O(1) |
| Binary Tree (balanced) | O(log n) | O(log n) | O(log n) | O(log n) |
| Heap | O(1) min/max | O(n) | O(log n) | O(log n) |
| Graph (adj. list) | O(1) | O(V+E) | O(1) | O(E) |
| Trie | O(m) | O(m) | O(m) | O(m) |
m = key length, V = vertices, E = edges. Hash table worst case is O(n) with collision storms, which almost never happens with a good hash function but is worth mentioning if asked.
Structure by structure: what actually matters for interviews
Arrays are the most common starting point. The patterns to learn are two-pointer (sorted arrays, palindromes), sliding window (subarray sums, max/min in a window), and prefix sums. Most “optimize a brute force O(n²) solution” problems reduce to one of these three.
Hash tables appear in roughly a third of all LeetCode mediums, maybe more. The core insight is: if you’re searching for something repeatedly, stop searching and index it first. Two Sum, group anagrams, and most “find matching pairs” problems are hash table problems with thin disguises.
Linked lists show up less than their reputation suggests. Reversals, detecting cycles (Floyd’s tortoise and hare), and merging sorted lists are the canonical patterns. If you know those three, you’ve covered the realistic scope of linked list questions in most interviews.
Stacks and queues become interesting with the monotonic stack pattern. A stack where you maintain elements in sorted order as you push and pop enables “next greater element,” “largest rectangle in histogram,” and about 11 other problems. That pattern alone is worth two solid hours of practice.
Binary trees reward candidates who can implement DFS and BFS from memory without reference. Recursive DFS is fine to start. Then practice iterative DFS using an explicit stack, because some interviewers specifically ask for the iterative version to see if you understand the call stack analogy.
Heaps (priority queues) handle any problem that requires repeatedly extracting the minimum or maximum from a changing dataset. Top K frequent elements, median from a data stream, and K closest points to origin are three classic heap problems that show up at companies across the board.
Graphs are where a lot of candidates have gaps. Union-find (disjoint sets) is undervalued for interview prep. A lot of connectivity and cycle-detection problems that people try to solve with complex DFS implementations become much cleaner with union-find once you know it.
Tries are genuinely niche. The autocomplete / prefix search problem is the one context where they’re clearly the right structure. If you’re running short on time, skip tries until you’ve drilled everything above.
The study order that actually works
Start with arrays and hash tables together, they’re complementary and reinforce each other. Then trees. Then stacks and queues. Then graphs. Heaps and tries last.
The Stack Overflow Developer Survey 2024 found that a significant share of developers report spending more than 30% of their interview prep time on algorithmic coding. The structure of that prep matters a lot. Many people plateau because they add new problem types before they’ve internalized the patterns from existing ones.
Spend at least 3 sessions per structure before moving on. The first session, you’re confused. The second, it starts to click. The third, you’re building an internal model. Moving faster than that produces fragile knowledge.
What to do in the 48 hours before an interview
Don’t try to learn anything new. Review your notes on the patterns you’ve already internalized. Do 3 to 4 warm-up problems you’ve seen before, not to re-solve them but to re-activate the pattern recognition.
According to the BLS Occupational Outlook for Software Developers, median pay for software developers in 2023 was $132,270. The interview process is the gate to that. Two weeks of focused, well-structured prep on these 8 structures will get most people further than two months of scattered problem-solving.
Communicating your thinking out loud
I’ve seen technically strong candidates fail because they go quiet while coding. Interviewers need to hear your reasoning, not just your output. Practice saying “I’m choosing a hash map here because lookup needs to be constant time” out loud, even when practicing alone. It feels awkward. That’s the point.
If you want to practice explaining your structure choices while you code, Craqly’s interview mode gives you a space to run through problems out loud and get feedback on whether your reasoning is coming across clearly, not just whether the code compiles.
Which of these 8 structures has the pattern that still doesn’t feel automatic? That’s the one to work on first.