Coding Interview Survival Guide: 7 High-Frequency Problem Types and Solution Frameworks

What Are Coding Interviews Really Testing?

In technical interviews, the coding-on-the-spot round is a must-have for virtually every major tech company. Whether you're a new grad or experienced hire, interviewers will ask you to write code on a whiteboard or online editor. They're testing not just "can you solve it," but "how do you think, communicate, and code."

Coding interviews truly assess three layers: problem decomposition ability, code implementation ability, and communication and optimization ability. Many candidates focus only on "getting it done," missing that interviewers care more about your thought process and how you articulate your approach.

This article systematically breaks down the 7 most frequent problem types in technical interviews, providing solution frameworks, classic example walkthroughs, and time/space complexity analysis for each type to help you build a systematic problem-solving methodology.

Type 1: Arrays and Two Pointers — The Easiest Points

Solution Framework

Array problems are the most fundamental part of algorithm interview techniques. The core approach is two pointers: using one pointer to traverse, two pointers converging from opposite ends, or two pointers sliding in the same direction, optimizing O(n²) brute force to O(n).

• Opposing pointers: Shrink from both ends toward the middle. Suitable for sorted array search, palindrome checking
• Fast-slow pointers: One pointer moves ahead, the other follows. Suitable for deduplication, sliding window preprocessing
• Read-write pointers: One pointer traverses, the other tracks valid positions. Suitable for in-place modification

Classic Examples

Two Sum (sorted array): Left pointer at the first element, right pointer at the last. Compare the sum with the target to decide which pointer to move. Time O(n), space O(1).

Remove duplicates from sorted array: Fast pointer traverses the array, slow pointer tracks the position of unique elements. When a different element is found, advance the slow pointer and assign. Time O(n), space O(1).

Complexity Analysis

Two-pointer problems generally have O(n) time complexity and O(1) space complexity. When encountering array problems in interviews, your first reflex should be "can I optimize with two pointers?"

Type 2: Linked List Operations — Pointer Thinking Is Key

Solution Framework

The core difficulty of linked list problems is that pointer operations are error-prone. The key is to draw diagrams and process step by step:

• Dummy head node: Unifies the logic for head and non-head nodes, avoiding boundary checks
• pre/cur/nxt three pointers: Standard operation pattern for reversing lists and deleting nodes
• Fast-slow pointers for cycle detection: Fast pointer moves two steps, slow pointer moves one step; if they meet, there's a cycle

Classic Examples

Reverse linked list: Use pre/cur/nxt three pointers. Each iteration points cur.next to pre, then advances all three pointers. Time O(n), space O(1).

Merge two sorted lists: Use a dummy head node to simplify logic. Compare current node values of both lists, attach the smaller one to the result. Time O(n+m), space O(1).

Complexity Analysis

Linked list problems typically have O(n) time and O(1) space. In interviews, always draw the diagram before coding. Make sure you understand the pointer directions before starting, otherwise debugging will waste significant time.

Type 3: Trees and Recursion — Understanding the Essence of Recursion

Solution Framework

Tree problems are almost always recursion problems. The essence of recursion is breaking a large problem into smaller problems of the same structure. When solving, think clearly about three things:

• Recursive function definition: What parameters does this function take, and what does it return
• Base case: When to return directly without recursing further
• Recursive relation: How to construct the current problem's result from subproblem results

Classic Examples

Maximum depth of binary tree: Define the function to return the maximum depth of the tree rooted at the current node. Base case: null node returns 0. Recursive relation: max(left subtree depth, right subtree depth) + 1. Time O(n), space O(h), where h is tree height.

Validate binary search tree: Define the function to check whether a subtree is within a valid range. Base case: null node returns true. Recursive relation: current node value is within (min, max), and both subtrees are valid. Time O(n), space O(h).

Complexity Analysis

Tree problems typically have O(n) time (each node visited once) and O(h) space (recursion stack depth). Worst case degenerates to a linked list with O(n) space; balanced tree has O(logn) space.

When preparing for technical interviews, many candidates focus only on practice problems and neglect how they present project experience on their resume. A strong technical resume should highlight your algorithm skills and engineering practice — use our resume tool to quickly generate a professional resume that showcases your technical strengths, leaving a positive impression before the coding round even begins.

Type 4: Graphs and BFS/DFS — Universal Search Frameworks

Solution Framework

The core of graph problems is traversing all reachable nodes. BFS and DFS are the two fundamental strategies:

• BFS (Breadth-First): Implemented with a queue, expanding level by level. Suitable for shortest paths, level-order traversal. Template: initialize queue → while queue not empty → pop current → expand neighbors → mark visited
• DFS (Depth-First): Implemented with a stack or recursion, going as deep as possible. Suitable for path search, connected components. Template: mark visited → process current → recurse/push all unvisited neighbors

Classic Examples

Number of islands: Traverse the grid. When encountering '1', launch DFS/BFS to mark all connected '1's as '0', increment island count. Time O(m×n), space O(m×n) worst case.

Word search: Search for a word in a 2D character grid using DFS backtracking. Key: temporarily mark visited cells, restore when backtracking. Time O(m×n×4^L), where L is word length.

Complexity Analysis

Graph problems typically have O(V+E) time, where V is the number of nodes and E is the number of edges. Grid graphs can be understood as O(m×n). In interviews, explain the necessity of the visited set to avoid infinite loops from repeated visits.

Type 5: Dynamic Programming — State Definition Is Core

Solution Framework

Dynamic programming is the most headache-inducing problem type in coding interview preparation, but it's manageable once you master the methodology. Four steps:

1. Define the state: What does dp[i] or dp[i][j] represent? This is the most critical step
2. Derive the state transition equation: How does dp[i] derive from smaller subproblems
3. Determine base cases and boundaries: What are the foundational values like dp[0], dp[1]
4. Determine traversal order: Ensure subproblems needed for dp[i] are already solved

Classic Examples

Climbing stairs: Define dp[i] as the number of ways to reach step i. Transition: dp[i] = dp[i-1] + dp[i-2]. Base cases: dp[1]=1, dp[2]=2. Time O(n), space O(n) optimizable to O(1).

Longest increasing subsequence: Define dp[i] as the length of the longest increasing subsequence ending at nums[i]. Transition: dp[i] = max(dp[j]+1), where j<i and nums[j]<nums[i]. Time O(n²), space O(n).

Complexity Analysis

1D DP typically has O(n²) or O(n) time, O(n) space often optimizable to O(1). 2D DP typically has O(m×n) time, O(m×n) space often optimizable to O(n). In interviews, write the basic solution first, then proactively propose space optimization — this is a bonus point.

Type 6: Strings and Sliding Window — Pattern Recognition Ability

Solution Framework

The high-frequency topic in string problems is sliding window, suitable for substring/subarray problems. The framework:

• Initialize: Both left and right pointers at the start, maintain a counter or hash map within the window
• Expand right pointer: Move right pointer forward, incorporate new elements into the window
• Shrink left pointer: When the window doesn't satisfy the condition, move the left pointer forward until it does again
• Update result: When the window satisfies the condition, update the optimal solution

Classic Examples

Longest substring without repeating characters: Use a hash map to record the most recent position of each character. Right pointer traverses the string; when encountering a duplicate, left pointer jumps past the duplicate position. Time O(n), space O(min(m,n)), where m is the character set size.

Minimum window substring: Use two hash maps for target character frequencies and window character frequencies. Expand right pointer; when the window satisfies coverage, shrink left pointer and update minimum length. Time O(n), space O(m).

Complexity Analysis

Sliding window problems typically have O(n) time (each element visited at most once by each pointer) and space depending on hash map size. In algorithm interview techniques, recognizing the sliding window pattern is a crucial step.

Type 7: Design Problems — Engineering Thinking in Action

Solution Framework

Design problems have the highest differentiation in technical interviews. They test not just algorithms but engineering thinking:

• Clarify requirements first: Data scale, operation frequency, thread safety requirements
• Choose data structures: Select the most appropriate combination based on operation characteristics
• Analyze trade-offs: Time for space or space for time, explain your reasoning
• Consider extensibility: If requirements change, is the current design easy to extend

Classic Examples

LRU Cache: Hash map + doubly linked list. Hash map for O(1) lookup, doubly linked list for O(1) insertion, deletion, and move-to-front. Get: lookup → move to front. Put: lookup → if exists, update and move to front → if not, insert at front → if over capacity, remove from tail. Time O(1), space O(capacity).

Design Twitter: Multiple data structure combination. User tweets with linked lists, follow relationships with hash sets, timeline with merge K sorted lists. The core is analyzing the frequency of each operation and choosing optimal data structures.

Complexity Analysis

Design problems have no fixed template. The core is choosing data structures based on requirements. In interviews, always confirm requirement details with the interviewer before starting to design — this reflects the professional habit of "communicate before coding."

5 Practical Tips for Coding on the Spot

1. Communicate before coding: After receiving the problem, restate the requirements, confirm edge cases, explain your approach, and only start coding after the interviewer acknowledges. This is the most important tip — many candidates start writing immediately, only to realize halfway through that they misunderstood the problem.
2. Brute force first, then optimize: First provide a working brute-force solution, explain its time complexity, then optimize step by step. Even if you can't find the optimal solution, a brute-force solution earns partial credit.
3. Think out loud: While coding, simultaneously explain what you're doing so the interviewer can follow your thought process. Silent coding is a major mistake — the interviewer can't tell if you truly understand or are just guessing.
4. Proactively test: After writing code, voluntarily test with edge cases: empty input, single element, duplicates, extreme values. This demonstrates your engineering discipline.
5. Analyze complexity: Proactively state time and space complexity, and discuss optimization possibilities. Even if the code has flaws, correct complexity analysis shows your professionalism.

Practice Strategy: From Zero to Offer in 3 Months

Month 1: Systematic Learning by Problem Type

Don't practice randomly. Tackle each of the 7 problem types in this article systematically. For each type, first understand the solution framework, then solve 5-10 classic problems to internalize the framework. The core of coding interviews isn't memorizing problems but mastering the thinking pattern for each type.

Month 2: Focused Breakthrough + Mistake Review

Concentrate on your weak problem types, 2-3 problems per day. The focus isn't how many problems you solve, but understanding why each approach works and whether there are alternative solutions. Build a mistake journal and review regularly.

Month 3: Mock Interviews + Speed Training

Find friends or use online platforms for mock interviews, completing one problem in 20-30 minutes under time pressure. The ultimate goal of coding interview preparation is being able to communicate clearly and code quickly under pressure. Also review all problem type frameworks to ensure you can recall them at any time.

FAQ

Can I use pseudocode in coding interviews?

It depends on the company. Some accept pseudocode, but most major tech companies require runnable code. We recommend practicing with real code. In interviews, you can write pseudocode first to organize your thoughts, then convert it to runnable code.

What should I do if I get stuck during an interview?

Don't stay silent. Tell the interviewer where you're stuck, share the direction you're currently thinking about, and ask for hints. Interviewers care more about your problem-solving process than whether you independently arrived at the answer. Proactively asking for help is far better than struggling in silence.

How many problems do I need to solve to pass technical interviews?

Quantity isn't the key — quality is. 200 problems solved thoroughly (understanding the framework for each, able to apply analogically) is more effective than 500 problems solved superficially. The core is mastering the solution frameworks for 7 problem types, so you can quickly categorize and apply them to new problems.

What if I can think of the optimal solution but can't implement it?

First write the solution you can implement, even if it's brute force. Then verbally describe the optimal solution's approach and explain the complexity difference. Partial optimal + complete implementation > perfect idea + zero code.

Do different companies have different coding interview styles?

Yes. ByteDance emphasizes algorithm difficulty, Tencent emphasizes engineering implementation, Alibaba emphasizes design thinking, and foreign companies emphasize the communication process. Adjust your preparation focus based on your target company, but the underlying frameworks for the 7 problem types are universal.

Preparing for technical interviews is a systematic engineering effort, from algorithm frameworks to project experience. A strong technical resume can build the interviewer's confidence before the coding round even starts — use our resume generator to precisely present your technical skills and project achievements, and give your interview an edge.