Data Structures You Actually Need for Coding Interviews

The 80/20 Rule of Interview Data Structures

When I first started prepping for coding interviews, I tried to learn every data structure from textbooks. AVL trees, red-black trees, skip lists, B-trees, Fibonacci heaps. I spent three weeks on that before a friend who'd just gotten into Amazon told me: "Dude, I used a hash map in four out of five rounds."

He wasn't exaggerating. The vast majority of coding interview problems lean on a surprisingly small set of data structures. If you've got limited prep time — and who doesn't — here's where to focus your energy.

Tier 1: Master These First

Arrays and Strings

Every single interview will involve arrays or strings. It's unavoidable. The key patterns to nail down:

• Two pointers — converging from both ends, fast/slow pointer
• Sliding window — fixed or variable size window across the array
• Prefix sums — precompute cumulative sums for range queries
• Sorting + scanning — sort first, then use pointers or binary search

A colleague once told me that if you truly master two pointers and sliding window, you can solve about 30% of all LeetCode mediums. I believe it.

Hash Maps (Dictionaries)

Hash maps are the Swiss Army knife of interviews. Anytime you need O(1) lookup, frequency counting, or checking for duplicates — hash map. Some classic applications:

• Two Sum (the most asked interview question ever)
• Finding duplicates in an array
• Character frequency problems
• Group anagrams
• Subarray sum equals K (hash map + prefix sum combo)

If your first instinct for a problem isn't "can I use a hash map here?" — train yourself until it is.

Trees (Binary Trees and BSTs)

Tree problems are everywhere at companies like Google and Meta. The key thing is to get really comfortable with recursion, because that's how you solve 90% of tree problems.

Core patterns you'll see:

• DFS traversals — inorder, preorder, postorder (know all three cold)
• BFS / level-order — using a queue, level by level
• Validate BST — the classic "is this tree a valid BST?"
• LCA (Lowest Common Ancestor) — shows up in many variations
• Path sum problems — sum along root-to-leaf or any path

Graphs

Graphs feel intimidating but most interview graph problems boil down to BFS or DFS. Seriously. Once you recognize that a problem is a graph problem (sometimes it's disguised as a grid, a word ladder, or a social network), you apply one of these traversals.

Must-know patterns:

• BFS for shortest path in unweighted graphs
• DFS for exploring all paths or connected components
• Topological sort — course scheduling, build order problems
• Union-Find — connected components, cycle detection

Tier 2: Know These Well

Stacks and Queues

Stacks aren't as common as arrays or hash maps, but when they show up, they're usually the only clean solution. Classic stack problems include:

• Valid parentheses
• Monotonic stack (next greater element, largest rectangle in histogram)
• Evaluate expressions
• Browser forward/back navigation

Queues are essential for BFS — that's their main interview use. Know how to implement BFS with a queue and you've covered most queue scenarios.

Heaps (Priority Queues)

Whenever you see "find the K largest/smallest" or "merge K sorted lists," think heap. The pattern is almost always the same:

• Use a min-heap of size K to track the K largest elements
• Use a max-heap for the K smallest elements
• For median-finding: maintain two heaps (max-heap for lower half, min-heap for upper half)

In Python, heapq is your friend. In Java, it's PriorityQueue. In JavaScript, you'll sadly need to implement one yourself or use a library — that's just how it is.

Tier 3: Know When They Appear

Tries

Tries come up in autocomplete, spell-checker, and word search problems. They're not super common, but when they are the right tool, nothing else works as elegantly.

If you see "implement autocomplete" or "find all words with prefix X" — it's a trie problem. Learn to build one and search it. That's usually enough.

Linked Lists

Skip linked list problems. Seriously. Okay, that's a slight exaggeration — you should know the basics (reverse a linked list, detect a cycle, merge two sorted lists). But I've interviewed at six companies in the last four years and got exactly one linked list question. Your time is better spent on trees and graphs.

When to Use What: A Decision Flowchart

Here's how I think about choosing data structures during an interview:

• Need O(1) lookup? → Hash map or hash set
• Need elements in sorted order? → BST, sorted array, or TreeMap
• Need to process in FIFO order? → Queue (probably BFS)
• Need to track most recent / match brackets? → Stack
• Need top K or streaming min/max? → Heap
• Hierarchical data or recursive structure? → Tree (DFS/BFS)
• Network/connection/path-finding? → Graph (BFS/DFS/Union-Find)
• String prefix matching? → Trie

Time Complexity Cheat Sheet

Data Structure	Access	Search	Insert	Delete
Array	O(1)	O(n)	O(n)	O(n)
Hash Map	N/A	O(1) avg	O(1) avg	O(1) avg
Binary Search Tree	O(log n)	O(log n)	O(log n)	O(log n)
Heap	O(1) top	O(n)	O(log n)	O(log n)
Stack / Queue	O(n)	O(n)	O(1)	O(1)
Trie	N/A	O(m)*	O(m)*	O(m)*
Linked List	O(n)	O(n)	O(1)**	O(1)**

*m = length of key. **At known position.

Study Order if You've Got Limited Time

Realistically, most people have 2-4 weeks to prep. Here's how I'd prioritize:

Week 1: Arrays/strings (two pointers, sliding window), hash maps. Do 15-20 problems mixing both.

Week 2: Binary trees (DFS, BFS, BST operations). Do 10-15 tree problems. Start easy (max depth, invert tree) and build up (serialize/deserialize, right side view).

Week 3: Graphs (BFS, DFS, topological sort, Union-Find). Do 10-12 problems. Grid problems (number of islands, shortest path in grid) are a great starting point because they're graphs that don't look like graphs.

Week 4: Stacks, heaps, and dynamic programming fundamentals. Fill in gaps from earlier weeks. Practice full mock interviews under time pressure.

If you only have one week, focus entirely on Tier 1 data structures. Honestly, you can pass most coding interviews with just arrays, hash maps, and trees if you know them deeply enough.

The Mistake That Costs People Offers

The biggest mistake isn't picking the wrong data structure — it's not recognizing the pattern. People see a problem and try to brute-force a solution from scratch instead of asking "what pattern is this?"

When I interviewed at a fintech company last year, I got a problem that looked completely novel. But 30 seconds of thinking revealed it was just a sliding window problem on a string. Once I recognized the pattern, the code took five minutes.

That pattern recognition comes from practice. Not from reading about data structures — from solving problems with them. Do the reps.

If you want structured practice with real-time guidance, Craqly's AI interview copilot walks you through coding problems and helps you identify the right data structure before you start coding. It's a solid way to build that pattern-matching muscle without spinning your wheels.