Essential Data Structures to Master
Coding interviews test your ability to choose the right data structure for each problem. Knowing when to use each structure is as important as knowing how they work. Here's a priority-ranked list of what to study:
Arrays & Strings
The most common interview topic. Nearly 40% of coding questions involve array or string manipulation.
Key operations:
- • Two-pointer technique
- • Sliding window
- • Prefix sums
- • In-place modification
Must-solve problems:
- • Two Sum (LeetCode #1)
- • Best Time to Buy & Sell Stock (#121)
- • Longest Substring Without Repeat (#3)
- • Merge Intervals (#56)
Hash Maps & Sets
The go-to tool for O(1) lookups. Used in ~30% of interview problems, often as the key insight that reduces time complexity from O(n²) to O(n).
When to use:
- • Counting frequencies
- • Checking for duplicates
- • Grouping by key
- • Caching/memoization
Must-solve problems:
- • Group Anagrams (#49)
- • Valid Anagram (#242)
- • LRU Cache (#146)
- • Subarray Sum Equals K (#560)
Trees & Binary Search Trees
Trees test recursive thinking and traversal strategies. Know DFS (preorder, inorder, postorder) and BFS (level-order) cold.
Key concepts:
- • Recursive vs. iterative traversal
- • BST properties and validation
- • Tree height, depth, and balance
- • Lowest Common Ancestor (LCA)
Must-solve problems:
- • Invert Binary Tree (#226)
- • Maximum Depth of Binary Tree (#104)
- • Validate BST (#98)
- • Binary Tree Level Order Traversal (#102)
Graphs
Graph problems are common at senior levels and test your ability to model relationships, find shortest paths, and detect cycles.
Key algorithms:
- • BFS for shortest path (unweighted)
- • DFS for connectivity and cycles
- • Topological sort (DAGs)
- • Union-Find (disjoint sets)
Must-solve problems:
- • Number of Islands (#200)
- • Clone Graph (#133)
- • Course Schedule (#207)
- • Word Ladder (#127)
Stacks, Queues & Heaps
These specialized structures solve specific patterns: monotonic stacks for next-greater-element, heaps for top-K and merge-K problems.
Common patterns:
- • Monotonic stack for histogram problems
- • Min-heap for Kth largest element
- • Queue for BFS implementation
- • Stack for valid parentheses
Must-solve problems:
- • Valid Parentheses (#20)
- • Kth Largest Element (#215)
- • Min Stack (#155)
- • Merge K Sorted Lists (#23)
The 8 Most Important Algorithm Patterns
Rather than memorizing 300 individual problems, learn these 8 patterns and you'll be able to solve most coding interview questions by recognizing which pattern applies.
①Two Pointers
Two pointers move through an array/string from different positions or speeds.
Use when: Sorted arrays, palindromes, remove duplicates, container with most water.
②Sliding Window
A dynamic window that expands or contracts while tracking a condition.
Use when: Subarray/substring problems, max sum, minimum window substring.
③Binary Search
Divide search space in half every iteration. Works beyond sorted arrays.
Use when: Sorted data, search range answers, rotated sorted array, peak element.
④BFS / DFS
Breadth-first for shortest path, depth-first for exhaustive exploration.
Use when: Trees, graphs, grids, connected components, shortest path.
⑤Dynamic Programming
Break problems into overlapping subproblems, store results to avoid recomputation.
Use when: Optimization problems, counting paths, knapsack, longest subsequence.
⑥Backtracking
Explore all possibilities, undoing choices that don't lead to valid solutions.
Use when: Permutations, combinations, N-Queens, Sudoku solver, word search.
⑦Greedy
Make the locally optimal choice at each step, hoping for a global optimum.
Use when: Interval scheduling, jump game, assign cookies, task scheduler.
⑧Divide & Conquer
Break problem into smaller subproblems, solve independently, merge results.
Use when: Merge sort, quick sort, closest pair, count inversions.
Time & Space Complexity Cheat Sheet
Every interviewer expects you to analyze the time and space complexity of your solution. Being able to immediately state "this is O(n log n) time and O(n) space" demonstrates deep understanding.
| Complexity | Name | Example | n=1M ops |
|---|---|---|---|
| O(1) | Constant | Hash map lookup, array access | 1 |
| O(log n) | Logarithmic | Binary search, balanced BST | 20 |
| O(n) | Linear | Array scan, hash map build | 1,000,000 |
| O(n log n) | Linearithmic | Merge sort, heap sort | 20,000,000 |
| O(n²) | Quadratic | Nested loops, bubble sort | 1012 ⚠️ |
| O(2ⁿ) | Exponential | Recursive Fibonacci, subset gen | 🔥 Infeasible |
Interview Rule of Thumb: If n ≤ 10,000, O(n²) might work. If n ≤ 1,000,000, you need O(n log n) or better. If n > 1,000,000, aim for O(n) or O(log n). Always discuss how your solution scales.
The 5-Step Problem-Solving Framework
This framework works for any coding interview question. Following it shows the interviewer you're structured and methodical — even if you don't find the optimal solution.
Understand the Problem (2-3 min)
Repeat the problem in your own words. Ask clarifying questions: edge cases, input size, constraints. Write 2-3 examples to confirm your understanding.
Identify the Pattern (2-3 min)
Which of the 8 algorithm patterns does this problem fit? Think about what data structure would best represent the data. Discuss your thought process out loud.
Plan Your Approach (3-5 min)
Outline your algorithm step-by-step before coding. State the expected time and space complexity. If the brute force is O(n²), discuss how to optimize to O(n log n) or O(n).
Write Clean Code (15-20 min)
Write readable code with descriptive variable names. Handle edge cases. Talk through your code as you write it. Start with the main logic, then add error handling.
Test and Debug (5 min)
Walk through your code with the examples from step 1. Test edge cases (empty input, single element, duplicates). Fix bugs calmly — debugging shows maturity.
How Many LeetCode Problems Should You Solve?
Quality matters more than quantity, but here's a practical benchmark:
75
Minimum Viable
Covers core patterns. Good for mid-tier companies. Focus on the "Blind 75" list.
150
Recommended
Strong prep for FAANG. Covers all major patterns with multiple variations.
300+
Competitive
For targeting Quant/HFT firms or staff+ FAANG roles. Includes Hard problems.
The #1 Mistake: Solving Without Understanding
If you solve a problem by reading the solution, you haven't really solved it. For each problem: (1) struggle with it for at least 20 minutes, (2) if you look at the solution, understand why it works, (3) close the solution and implement it from scratch, (4) revisit it after 3 days. Spaced repetition is how you internalize patterns.