Every coding interview follows predictable patterns. Companies like Google, Meta, Amazon, and Microsoft ask the same core questions year after year—they just vary the details.

This guide covers the 50 most frequently asked coding interview questions, organized by pattern. Each question includes:

The problem statement
Key insight or approach
Time and space complexity
A link to practice

If you want to master these questions faster, Interview AiBox provides AI-powered mock interviews with real-time feedback.

Array & String Questions (12 questions)
Linked List Questions (6 questions)
Tree & Graph Questions (10 questions)
Dynamic Programming Questions (10 questions)
Hash Table & Set Questions (6 questions)
Stack & Queue Questions (6 questions)

Array & String Questions

Arrays and strings appear in almost every coding interview. Master these patterns first.

Two Sum

Problem: Given an array of integers and a target sum, return indices of two numbers that add up to the target.

Key Insight: Use a hash map to store each number's index. For each element, check if target - current exists in the map.

Complexity: O(n) time, O(n) space

Practice: LeetCode #1

Best Time to Buy and Sell Stock

Problem: Find the maximum profit from buying and selling a stock once.

Key Insight: Track the minimum price seen so far. For each day, calculate potential profit if selling at current price.

Complexity: O(n) time, O(1) space

Practice: LeetCode #121

Contains Duplicate

Problem: Determine if an array contains any duplicate values.

Key Insight: Use a hash set. If any element already exists in the set, return true.

Complexity: O(n) time, O(n) space

Practice: LeetCode #217

Product of Array Except Self

Problem: Return an array where each element is the product of all other elements.

Key Insight: Use prefix and suffix products. Two passes: left-to-right for prefix, right-to-left for suffix.

Complexity: O(n) time, O(1) space (excluding output)

Practice: LeetCode #238

Maximum Subarray

Problem: Find the contiguous subarray with the largest sum.

Key Insight: Kadane's algorithm. Keep running sum, reset to 0 if negative.

Complexity: O(n) time, O(1) space

Practice: LeetCode #53

3Sum

Problem: Find all unique triplets that sum to zero.

Key Insight: Sort the array. For each element, use two pointers to find pairs that sum to the negative of that element.

Complexity: O(n²) time, O(1) space (excluding output)

Practice: LeetCode #15

Merge Intervals

Problem: Merge all overlapping intervals.

Key Insight: Sort by start time. Merge if current start ≤ previous end.

Complexity: O(n log n) time, O(n) space

Practice: LeetCode #56

Group Anagrams

Problem: Group strings that are anagrams of each other.

Key Insight: Use sorted string as key in hash map. All anagrams have the same sorted form.

Complexity: O(n × k log k) time, O(n × k) space (k = average string length)

Practice: LeetCode #49

Longest Substring Without Repeating Characters

Problem: Find the length of the longest substring without duplicate characters.

Key Insight: Sliding window with hash set. Expand right, shrink left when duplicate found.

Complexity: O(n) time, O(min(n, m)) space (m = charset size)

Practice: LeetCode #3

Valid Parentheses

Problem: Determine if a string of brackets is valid (properly closed).

Key Insight: Use a stack. Push opening brackets, pop when matching closing bracket found.

Complexity: O(n) time, O(n) space

Practice: LeetCode #20

Minimum Window Substring

Problem: Find the minimum window substring containing all characters of another string.

Key Insight: Sliding window with character frequency map. Expand right, contract left when all characters found.

Complexity: O(n + m) time, O(k) space (k = unique characters)

Practice: LeetCode #76

Trapping Rain Water

Problem: Calculate how much rainwater can be trapped between bars.

Key Insight: For each position, water = min(max_left, max_right) - height. Precompute max_left and max_right arrays.

Complexity: O(n) time, O(n) space

Practice: LeetCode #42

Linked List Questions

Linked list problems test your ability to manipulate pointers carefully.

Reverse Linked List

Problem: Reverse a singly linked list.

Key Insight: Iterate through list, reversing pointers one at a time. Keep track of previous, current, and next.

Complexity: O(n) time, O(1) space

Practice: LeetCode #206

Merge Two Sorted Lists

Problem: Merge two sorted linked lists into one sorted list.

Key Insight: Use dummy head. Compare nodes, attach smaller one, advance that pointer.

Complexity: O(n + m) time, O(1) space

Practice: LeetCode #21

Linked List Cycle

Problem: Determine if a linked list has a cycle.

Key Insight: Floyd's tortoise and hare. Slow pointer moves 1 step, fast moves 2. If they meet, cycle exists.

Complexity: O(n) time, O(1) space

Practice: LeetCode #141

Remove Nth Node From End

Problem: Remove the nth node from the end of a linked list.

Key Insight: Two pointers. Move first pointer n steps ahead, then move both until first reaches end.

Complexity: O(n) time, O(1) space

Practice: LeetCode #19

Reorder List

Problem: Reorder list so that L0 → Ln → L1 → Ln-1 → L2 → Ln-2...

Key Insight: Three steps: find middle, reverse second half, merge alternately.

Complexity: O(n) time, O(1) space

Practice: LeetCode #143

Copy List with Random Pointer

Problem: Deep copy a linked list where each node has a random pointer.

Key Insight: First pass: create copy nodes and insert after originals. Second pass: set random pointers. Third pass: separate lists.

Complexity: O(n) time, O(1) space (excluding output)

Practice: LeetCode #138

Tree & Graph Questions

Tree and graph problems appear in almost every senior-level interview.

Maximum Depth of Binary Tree

Problem: Find the maximum depth of a binary tree.

Key Insight: Recursive: max(depth(left), depth(right)) + 1. Or BFS level by level.

Complexity: O(n) time, O(h) space (h = height)

Practice: LeetCode #104

Validate Binary Search Tree

Problem: Determine if a tree is a valid BST.

Key Insight: Each node must be within valid range (min, max). Update range as you traverse.

Complexity: O(n) time, O(h) space

Practice: LeetCode #98

Level Order Traversal

Problem: Return level-by-level traversal of a binary tree.

Key Insight: BFS with queue. Process one level at a time.

Complexity: O(n) time, O(n) space

Practice: LeetCode #102

Lowest Common Ancestor

Problem: Find the lowest common ancestor of two nodes in a BST.

Key Insight: In BST, LCA is the first node where one target is in left subtree and other in right.

Complexity: O(h) time, O(1) space

Practice: LeetCode #235

Serialize and Deserialize Binary Tree

Problem: Convert a binary tree to string and back.

Key Insight: Use preorder traversal with null markers. Reconstruct by reading in same order.

Complexity: O(n) time, O(n) space

Practice: LeetCode #297

Number of Islands

Problem: Count the number of islands (connected 1s) in a grid.

Key Insight: DFS or BFS. When you find a 1, mark all connected 1s as visited.

Complexity: O(m × n) time, O(m × n) space worst case

Practice: LeetCode #200

Clone Graph

Problem: Deep clone a graph represented by nodes with neighbors.

Key Insight: Use hash map to track visited nodes. Recursively clone each node and its neighbors.

Complexity: O(n) time, O(n) space

Practice: LeetCode #133

Course Schedule

Problem: Determine if you can finish all courses given prerequisites.

Key Insight: Detect cycle in directed graph using topological sort or DFS with three states.

Complexity: O(n + e) time, O(n + e) space

Practice: LeetCode #207

Pacific Atlantic Water Flow

Problem: Find cells where water can flow to both oceans.

Key Insight: Start from oceans and work backwards. Use two visited sets, find intersection.

Complexity: O(m × n) time, O(m × n) space

Practice: LeetCode #417

Word Search

Problem: Determine if a word exists in a 2D board by adjacent cells.

Key Insight: DFS with backtracking. Mark cell as visited, try all directions, unmark when backtracking.

Complexity: O(n × 4^L) time (L = word length), O(L) space

Practice: LeetCode #79

Dynamic Programming Questions

DP problems are the hardest but follow recognizable patterns.

Climbing Stairs

Problem: Count ways to climb n stairs, taking 1 or 2 steps at a time.

Key Insight: dp[i] = dp[i-1] + dp[i-2]. Same as Fibonacci.

Complexity: O(n) time, O(1) space

Practice: LeetCode #70

Coin Change

Problem: Find minimum coins needed to make an amount.

Key Insight: dp[i] = min(dp[i], dp[i - coin] + 1) for each coin.

Complexity: O(n × m) time, O(n) space (n = amount, m = coins)

Practice: LeetCode #322

Longest Increasing Subsequence

Problem: Find the length of the longest increasing subsequence.

Key Insight: dp[i] = longest LIS ending at i. Or use binary search for O(n log n).

Complexity: O(n²) time, O(n) space (or O(n log n) with binary search)

Practice: LeetCode #300

Longest Common Subsequence

Problem: Find the length of the longest common subsequence of two strings.

Key Insight: 2D DP. If chars match: dp[i][j] = dp[i-1][j-1] + 1. Else: max of two possibilities.

Complexity: O(m × n) time, O(m × n) space

Practice: LeetCode #1143

Word Break

Problem: Determine if a string can be segmented into dictionary words.

Key Insight: dp[i] = true if s[0:i] can be broken. Check all possible splits.

Complexity: O(n²) time, O(n) space

Practice: LeetCode #139

House Robber

Problem: Maximize money robbed without robbing adjacent houses.

Key Insight: dp[i] = max(dp[i-1], dp[i-2] + nums[i]). Rob or skip current house.

Complexity: O(n) time, O(1) space

Practice: LeetCode #198

Unique Paths

Problem: Count unique paths from top-left to bottom-right of a grid.

Key Insight: dp[i][j] = dp[i-1][j] + dp[i][j-1]. Can optimize to 1D array.

Complexity: O(m × n) time, O(n) space

Practice: LeetCode #62

Decode Ways

Problem: Count ways to decode a string of digits to letters.

Key Insight: dp[i] depends on single digit (if valid) and two-digit combination (if valid).

Complexity: O(n) time, O(1) space

Practice: LeetCode #91

Partition Equal Subset Sum

Problem: Determine if array can be partitioned into two equal-sum subsets.

Key Insight: Find subset with sum = total/2. Use knapsack-style DP.

Complexity: O(n × sum) time, O(sum) space

Practice: LeetCode #416

Edit Distance

Problem: Find minimum operations to convert one string to another.

Key Insight: 2D DP. Insert, delete, or replace. dp[i][j] = min of three operations + 1.

Complexity: O(m × n) time, O(m × n) space

Practice: LeetCode #72

Hash Table & Set Questions

Hash tables provide O(1) lookups—essential for many optimizations.

Longest Consecutive Sequence

Problem: Find the length of the longest consecutive elements sequence.

Key Insight: Use a set. For each number, only start counting if n-1 not in set.

Complexity: O(n) time, O(n) space

Practice: LeetCode #128

Subarray Sum Equals K

Problem: Count subarrays that sum to k.

Key Insight: Use prefix sum with hash map. Count how many prefix sums equal current_sum - k.

Complexity: O(n) time, O(n) space

Practice: LeetCode #560

Top K Frequent Elements

Problem: Return the k most frequent elements.

Key Insight: Count frequencies, then use bucket sort (index = frequency) or min-heap of size k.

Complexity: O(n) time with bucket sort, O(n log k) with heap

Practice: LeetCode #347

Find All Anagrams in a String

Problem: Find all start indices of anagrams of pattern in string.

Key Insight: Sliding window with frequency map. Compare window freq to pattern freq.

Complexity: O(n) time, O(k) space (k = unique chars in pattern)

Practice: LeetCode #438

LRU Cache

Problem: Design an LRU (Least Recently Used) cache.

Key Insight: Hash map + doubly linked list. Map for O(1) access, list for O(1) reorder.

Complexity: O(1) for get and put

Practice: LeetCode #146

Insert Delete GetRandom O(1)

Problem: Design a structure with O(1) insert, delete, and getRandom.

Key Insight: ArrayList + HashMap. Map stores value → index. Swap with last element on delete.

Complexity: O(1) for all operations

Practice: LeetCode #380

Stack & Queue Questions

Stacks are perfect for problems involving matching, nesting, or reversal.

Min Stack

Problem: Design a stack that supports push, pop, top, and getMin in O(1).

Key Insight: Use two stacks, or store (value, current_min) pairs.

Complexity: O(1) for all operations

Practice: LeetCode #155

Evaluate Reverse Polish Notation

Problem: Evaluate an expression in RPN (postfix) notation.

Key Insight: Use stack. Push numbers, pop two when operator found, push result.

Complexity: O(n) time, O(n) space

Practice: LeetCode #150

Daily Temperatures

Problem: For each day, find how many days until a warmer temperature.

Key Insight: Monotonic decreasing stack. Store indices, pop when warmer day found.

Complexity: O(n) time, O(n) space

Practice: LeetCode #739

Car Fleet

Problem: Count how many car fleets arrive at destination.

Key Insight: Sort by position. Use stack to track fleets. Cars that catch up merge into fleet.

Complexity: O(n log n) time, O(n) space

Practice: LeetCode #853

Largest Rectangle in Histogram

Problem: Find the largest rectangle in a histogram.

Key Insight: Monotonic stack. For each bar, find left and right boundaries where bars are shorter.

Complexity: O(n) time, O(n) space

Practice: LeetCode #84

Basic Calculator

Problem: Evaluate a string expression with +, -, (, ).

Key Insight: Use stack for parentheses. Track sign. Handle nested expressions.

Complexity: O(n) time, O(n) space

Practice: LeetCode #224

How to Practice These Questions

The 80/20 Rule

You don't need to solve all 50 questions perfectly. Focus on:

Patterns over problems. Once you understand sliding window, you can solve 10 similar problems.
Time-boxed practice. Give yourself 25 minutes per problem. If stuck, read the solution, then redo from scratch the next day.
Explain out loud. Interviewers want to hear your thought process. Practice narrating while you code.

Week 1: Array & String (Questions 1-12) Week 2: Linked List + Hash Table (Questions 13-18, 39-44) Week 3: Trees & Graphs (Questions 19-28) Week 4: Dynamic Programming (Questions 29-38) Week 5: Stack & Queue + Review (Questions 45-50)

AI-Powered Practice

Reading solutions isn't enough. You need to practice explaining your approach under pressure.

Interview AiBox provides:

Real-time feedback on your explanations
Mock interviews with AI interviewers
Progress tracking across all question types

Instead of grinding through LeetCode alone, practice with an AI that can challenge your assumptions and suggest improvements.

FAQ

How many of these questions will I actually see?

Most interviews include 1-2 coding questions from this list or variations. The exact questions depend on the company—Google leans toward graphs and DP, while startups often ask array and string problems.

Should I memorize the solutions?

No. Memorization fails when the problem changes slightly. Focus on understanding the pattern behind each solution. If you can explain why an approach works, you can adapt it to new problems.

What if I can't solve a problem in 25 minutes?

That's normal. Read the solution, understand it deeply, and redo the problem the next day without looking. Repeat until you can solve it from scratch. This "spaced repetition" approach is more effective than spending hours on one problem.

Are these questions enough for FAANG interviews?

These 50 questions cover the core patterns that appear in 80% of coding interviews. For FAANG, also practice:

Harder variations of these problems
System design (for senior roles)
Behavioral questions

See our System Design Interview Guide and Behavioral Interview Questions for complete preparation.

How is this different from LeetCode's Top Interview Questions?

This list is curated for 2026 interview trends. We've removed outdated questions and added newer patterns that companies are asking today. We also prioritize questions that test multiple skills—many problems here combine two or more techniques.

Next Steps

Start with your weakest area. If you struggle with DP, begin with questions 29-38.
Practice with AI feedback. Try Interview AiBox for real-time interview simulation.
Read our complete guides:
Download Interview AiBox and start practicing today.