How do I get better at pattern recognition for coding interviews?

Study patterns, not individual problems. For each pattern (Sliding Window, Two Pointers, BFS, DP, etc.), learn the template and the conditions that trigger it. When you see "sorted input", think binary search or two pointers. When you see "top K elements", think heap. After solving 3–5 problems per pattern, recognition becomes automatic.

What data structure should I use for each type of problem?

Key heuristics: sorted input → binary search or two pointers; O(1) lookup needed → hash map or set; cycle detection or midpoint → fast/slow pointers; top/bottom K → heap; overlapping intervals → sort by start time; count ways or optimal split → dynamic programming; all subsets/permutations → backtracking.

When should I use BFS vs DFS for tree and graph problems?

Use BFS when you need the shortest path, level-by-level traversal, or the minimum number of steps. Use DFS when you need to explore all paths, detect cycles, or traverse a tree recursively (pre/in/post-order). For disconnected graphs, both work — BFS is slightly easier to implement iteratively with a queue.

How do I know when to use dynamic programming?

DP applies when: (1) the problem asks to count ways, maximize/minimize a value, or check feasibility; (2) the problem has overlapping subproblems (same sub-inputs are computed multiple times); and (3) there's an optimal substructure (optimal solution builds on optimal solutions to subproblems). If a greedy approach is provably correct, use that instead — it's simpler.

What should I do when I am stuck on a coding interview problem?

Follow this order: (1) Work through a small example by hand. (2) State the brute-force O(n²) or O(2ⁿ) solution out loud — it shows you understand the problem. (3) Look for inefficiency: what are you recomputing? Can a hash map eliminate a nested loop? (4) Map to a known pattern using the condition → pattern heuristics. (5) Think about the data structure that matches the access pattern.

How do I handle edge cases in coding interviews?

Always test: empty input, single element, all elements identical, negative numbers, maximum constraints (overflow), and the boundary conditions your algorithm depends on (e.g. window of size equal to array). Mention these before coding — it signals thoroughness. The most common bugs come from off-by-one errors (use < vs <=) and not handling the empty/null case.

Interview Tips

Coding Interview Tips — How to Solve LeetCode Problems by Pattern

Based on problem constraints, use these heuristics to identify possible approaches when unsure.

Arrays & Strings

Condition	Approach
Input is sorted	Binary search or two pointers
Need O(1) lookup or existence check	Hash table (set or map)
Problem requires in-place modification	Two pointers or index swap
Common prefix or string matching	Map counting or Trie
XOR, toggling, or bit flags	Bit manipulation

Subarrays & Sequences

Condition	Approach
Max or min subarray sum or length	Dynamic programming or sliding window
Sliding window max or min	Monotonic deque
Next greater or smaller element	Monotonic stack
Range sum query	Prefix sum, Binary Indexed Tree, or segment tree

Trees & Graphs

Condition	Approach
Tree traversal or path problem	DFS (recursion or stack) or BFS (queue)
Graph traversal or connected components	DFS / BFS / Union-Find
2D grid connectivity or shortest path	BFS or DFS or DP on grid
Grouping or merging disjoint sets	Union-Find or DFS
Task ordering with dependencies	Topological sort

Linked Lists & Stacks

Condition	Approach
Cycle detection or finding midpoint in a linked list	Fast and slow pointers
Need to simulate recursion iteratively	Explicit stack

Sorting & Intervals

Condition	Approach
Top K or least K elements	Min/max heap, Quickselect, or bucket sort
Merging multiple sorted sequences	Merge sort pattern or min-heap
Overlapping interval handling	Sort by start time, then sweep line
Processing a continuous data stream	Heap or custom data structure

Optimization

Condition	Approach
All permutations, combinations, or subsets	Backtracking
Count ways or divide problem optimally	Greedy (if provable) or Dynamic Programming

General

Condition	Approach
None of the above fit	Hash map or set — O(1) time, O(n) space
Want to avoid extra space	Sort the input first — O(n log n) time, O(1) space

🎙️ Interview Room Psychology

The "Thinking Out Loud" Framework: How to Communicate Under Pressure

In tier-1 tech interviews (FAANG / Big Tech), interviewers are not evaluating whether you have memorized code syntax; they are assessing what it is like to collaborate with you as a software engineer on a production team. Candidates who remain silent for 15 minutes and produce code receive lower signals than candidates who vocalize trade-offs.

Pacing the 45-Minute Interview

00–05m: Requirements clarification & constraint confirmation
05–15m: High-level design, naive approach & trade-off discussion
15–30m: Clean modular implementation
30–40m: Manual dry run with non-trivial test case & edge checks
40–45m: Time/space analysis & your questions for interviewer

What to Say When You Are Stuck

Never freeze or apologize. Instead, externalize your mental model: "I'm considering whether a monotonic stack or a two-pointer approach fits this condition better. The challenge is preserving the original indices while maintaining order. Let me write out a 4-element trace on the whiteboard to see the invariant."

Jump to section

Arrays & Strings Subarrays & Sequences Trees & Graphs Linked Lists & Stacks Sorting & Intervals Optimization General

Browse all patterns → Practice problems → Big O reference → Cheat sheets →