Prepare for coding interviews with our list of the top 30 most common LeetCode questions. Master your LeetCode prep!
Navigating technical interviews, especially for leading tech companies, demands strong problem-solving and algorithmic skills. LeetCode has become an indispensable platform for honing these abilities, offering a vast array of coding challenges designed to test your proficiency in data structures and algorithms. While specific question lists for individual companies aren't always publicly disclosed, the core concepts tested through LeetCode remain universal across the tech industry. Companies seek candidates who can efficiently break down complex problems, implement optimal solutions, and articulate their thought process clearly. This guide provides a comprehensive overview of 30 common LeetCode interview questions, typical of what you might encounter in a rigorous technical interview at companies prioritizing deep technical aptitude. Preparing with these foundational problems will equip you with the essential patterns and techniques needed to excel and demonstrate your readiness for demanding engineering roles. Mastering these questions builds a robust understanding of computer science fundamentals, crucial for tackling novel challenges in real-world scenarios.
What Are LeetCode Interview Questions?
LeetCode interview questions are algorithmic and data structure problems found on the LeetCode platform, simulating coding challenges in software development. They span topics like arrays, strings, linked lists, trees, graphs, and dynamic programming, ranging from easy to hard. In interviews, these questions evaluate a candidate's problem-solving skills, ability to write efficient and correct code, and understanding of core computer science concepts. Companies use them to assess how candidates approach new problems, handle edge cases, optimize for time and space complexity, and articulate solutions. Strong performance indicates a robust technical foundation, crucial for complex software roles.
Why Do Interviewers Ask LeetCode Interview Questions?
Interviewers ask LeetCode-style questions to assess core technical competencies. They evaluate problem-solving: can you break down complex issues, identify patterns, and devise logical solutions? These questions gauge your algorithmic thinking, revealing if you choose optimal algorithms and data structures for performance. They test coding proficiency, ensuring clean, efficient, and bug-free code under time constraints. Furthermore, they reveal how you handle constraints and edge cases, vital for robust software. Finally, these problems offer insight into communication—how effectively you explain your approach and justify choices. For companies operating at scale, these foundational skills are paramount for high-performance systems and indicate potential contribution to a technical team.
Preview List
1. Two Sum
2. Longest Substring Without Repeating Characters
3. Merge Intervals
4. Maximum Depth of Binary Tree
5. Validate Binary Search Tree
6. Top K Frequent Elements
7. Coin Change
8. Number of Islands
9. Reverse Linked List
10. Valid Parentheses
11. Product of Array Except Self
12. Best Time to Buy and Sell Stock
13. Longest Palindromic Substring
14. Group Anagrams
15. Kth Smallest Element in a BST
16. Find All Anagrams in a String
17. House Robber
18. Climb Stairs
19. Subtree of Another Tree
20. Binary Tree Level Order Traversal
21. Symmetric Tree
22. Path Sum
23. Convert Sorted Array to Binary Search Tree
24. Implement Trie (Prefix Tree)
25. Search in Rotated Sorted Array
26. Median of Two Sorted Arrays
27. Container With Most Water
28. 3Sum
29. Merge Two Sorted Lists
30. Lowest Common Ancestor of a Binary Search Tree
1. Two Sum
Why you might get asked this:
This classic problem tests your ability to use hash maps for efficient lookups, demonstrating understanding of time-space tradeoffs. It's a fundamental problem often used as a warm-up.
How to answer:
Iterate through the array, for each number, calculate the complement needed. Check if the complement exists in a hash map. If not, add the current number to the map.
Example answer:
Create a hash map `nummap`. Iterate `nums` with index `i`. Calculate `complement = target - nums[i]`. If `complement` is in `nummap`, return `[nummap[complement], i]`. Otherwise, add `nums[i]` with its index `i` to `nummap`. This ensures O(n) time complexity.
2. Longest Substring Without Repeating Characters
Why you might get asked this:
Tests your grasp of sliding window technique and efficient character tracking, often with hash sets or arrays, to find optimal subarrays/substrings.
How to answer:
Use a sliding window. Maintain a set of characters in the current window. Expand the window right, adding new chars. If a duplicate is found, shrink the window from the left until unique.
Example answer:
Initialize `left = 0`, `maxlen = 0`, and a `charset`. Iterate `right` pointer. Add `s[right]` to `charset`. If `s[right]` is already in `charset`, remove `s[left]` from set and increment `left` until unique. Update `max_len` with `right - left + 1`.
3. Merge Intervals
Why you might get asked this:
Evaluates your ability to handle interval overlaps and manage sorted data. It's a common problem in scheduling and data range management.
How to answer:
Sort the intervals by their start times. Iterate through the sorted intervals, merging overlapping ones. If current interval overlaps with last merged, extend it; otherwise, add to result.
Example answer:
Sort `intervals` by `interval[0]`. Initialize `merged = []`. For each interval: if `merged` is empty or current interval does not overlap with `merged`'s last interval, append it. Else, update `merged`'s last interval end with `max(lastend, currentend)`.
4. Maximum Depth of Binary Tree
Why you might get asked this:
A basic tree traversal problem testing recursion or iteration with a stack/queue. It's fundamental for understanding tree properties.
How to answer:
Recursively find the maximum depth of the left and right subtrees. The depth of the current node is 1 plus the maximum of these two depths. Base case is null node (depth 0).
Example answer:
Define a recursive function `maxdepth(node)`. If `node` is `None`, return 0. Otherwise, return `1 + max(maxdepth(node.left), max_depth(node.right))`. This performs a DFS-like traversal.
5. Validate Binary Search Tree
Why you might get asked this:
Checks your understanding of BST properties (left < root < right) and how to maintain boundary conditions during traversal, often with recursion.
How to answer:
Perform an in-order traversal, ensuring each element is greater than the previous one. Or, use recursion with `minval` and `maxval` parameters to enforce BST rules for each subtree.
Example answer:
Implement a helper function `isvalid(node, minval, maxval)`. If `node` is `None`, return `True`. Check if `node.val` is within `minval` and `maxval`. Recursively call `isvalid` for left child with `(minval, node.val)` and right child with `(node.val, maxval)`.
6. Top K Frequent Elements
Why you might get asked this:
Assesses your use of hash maps for frequency counting and min-heaps (priority queues) for efficiently finding the top K elements, showcasing data structure choice.
How to answer:
First, count frequencies of all elements using a hash map. Then, use a min-heap to store (frequency, element) pairs, keeping only the top K elements.
Example answer:
Count element frequencies using a dictionary `freqmap`. Create a min-heap. For each `(num, freq)` in `freqmap`, push `(freq, num)` to heap. If heap size exceeds `k`, pop the smallest. Finally, extract elements from heap.
7. Coin Change
Why you might get asked this:
A classic dynamic programming problem that evaluates your ability to break down problems into subproblems and build optimal solutions bottom-up.
How to answer:
Use dynamic programming. Create a DP array `dp` where `dp[i]` is the minimum coins for amount `i`. Initialize `dp[0]=0` and others to infinity. Iterate through amounts and coins.
Example answer:
Initialize `dp` array of size `amount + 1` with `infinity`, `dp[0] = 0`. Iterate from `i = 1` to `amount`. For each `coin` in `coins`, if `i >= coin`, set `dp[i] = min(dp[i], dp[i - coin] + 1)`. Return `dp[amount]` or -1 if `infinity`.
8. Number of Islands
Why you might get asked this:
Tests graph traversal algorithms like DFS or BFS on a grid. It checks your ability to explore connected components and mark visited nodes.
How to answer:
Iterate through the grid. When an '1' is found (an unvisited land cell), increment island count and perform DFS/BFS from that cell to mark all connected land cells as visited ('0').
Example answer:
Iterate `(r, c)` over `grid`. If `grid[r][c] == '1'`, increment `count` and start a DFS or BFS from `(r, c)`. The traversal marks all connected '1's as '0' to avoid recounting. Ensure bounds checking.
9. Reverse Linked List
Why you might get asked this:
A fundamental linked list manipulation problem. Tests iterative or recursive approaches and careful pointer management.
How to answer:
Iteratively: Maintain three pointers: `prev`, `current`, `next_node`. Move `current.next` to point to `prev`, then advance all pointers. Recursively: Reverse the rest of the list and then fix the current node's pointer.
Example answer:
Iterative: Initialize `prev = None`, `curr = head`. While `curr` is not `None`, store `nextnode = curr.next`. Set `curr.next = prev`. Update `prev = curr`, `curr = nextnode`. Return `prev`.
10. Valid Parentheses
Why you might get asked this:
Assesses your understanding and use of stacks to match opening and closing characters. It's a classic problem demonstrating stack applicability.
How to answer:
Iterate through the string. If an opening bracket, push to stack. If closing, check if stack is empty or top matches. If not, invalid. Pop matching opening bracket.
Example answer:
Use a stack. Define a map for `closingtoopening` brackets. Iterate through string `s`. If `char` is an opening bracket, push it. If `char` is a closing bracket, check if stack is empty or `stack.pop()` doesn't match `char`'s corresponding opening. Return `stack` empty at end.
11. Product of Array Except Self
Why you might get asked this:
Tests array manipulation and finding solutions without division, often by combining left and right products, demonstrating clever prefix/suffix array use.
How to answer:
Create a `result` array. First pass: calculate prefix products. Second pass: calculate suffix products and multiply with prefix products. Avoid division.
Example answer:
Initialize `result` array of same size as `nums`. Calculate prefix products: `result[i]` holds product of `nums[0...i-1]`. Then, iterate backwards: `rightprod` accumulates suffix products, multiplying `result[i]` by `rightprod` before updating `right_prod` with `nums[i]`.
12. Best Time to Buy and Sell Stock
Why you might get asked this:
A simple dynamic programming or greedy problem. Tests finding optimal values within a sequence by keeping track of minimums and maximum profits.
How to answer:
Iterate through prices, keeping track of the minimum price encountered so far. At each step, calculate the potential profit if sold today and update the maximum profit found.
Example answer:
Initialize `minprice = float('inf')` and `maxprofit = 0`. Iterate through `prices`. If `price < minprice`, update `minprice = price`. Else, update `maxprofit = max(maxprofit, price - minprice)`. Return `maxprofit`.
13. Longest Palindromic Substring
Why you might get asked this:
Tests string manipulation, often with dynamic programming or expand-around-center approach. Assesses handling substrings and palindrome properties.
How to answer:
For each character, consider it as the center of a palindrome (odd length) and between two characters (even length). Expand outwards to find the longest palindrome.
Example answer:
Iterate `i` from `0` to `len(s)-1`. For each `i`, call a helper `expand(s, i, i)` for odd length palindromes and `expand(s, i, i+1)` for even length. The `expand` function grows outward while characters match, returning the palindrome. Keep track of the longest.
14. Group Anagrams
Why you might get asked this:
Tests your ability to categorize strings based on a canonical form (e.g., sorted string) and use hash maps to group them efficiently.
How to answer:
For each string, sort its characters to create a unique "key" (e.g., "aet"). Store strings in a hash map where keys are sorted strings and values are lists of original strings.
Example answer:
Create a `defaultdict(list)` called `anagramgroups`. For each `word` in `strs`, sort its characters to form a `key = "".join(sorted(word))`. Append the `word` to `anagramgroups[key]`. Return `anagram_groups.values()`.
15. Kth Smallest Element in a BST
Why you might get asked this:
Tests in-order traversal of a BST, which naturally produces sorted elements. You can stop after finding the Kth element.
How to answer:
Perform an in-order traversal (recursive or iterative). Maintain a counter. When the counter reaches K, the current node's value is the Kth smallest.
Example answer:
Recursive in-order traversal: Create a `list` to store visited nodes. In the traversal function, if `node` is valid, recurse left, add `node.val` to list, recurse right. Return `list[k-1]`. Iterative with stack is also possible.
16. Find All Anagrams in a String
Why you might get asked this:
Tests sliding window with character frequency maps. It's an extension of substring problems, requiring efficient frequency updates.
How to answer:
Use a sliding window of `p`'s length. Maintain frequency maps for `p` and the current window. Expand window, update frequencies. When window size matches `p`, check frequency map equality.
Example answer:
Calculate character frequencies for `p` (target map). Initialize `windowmap` for `s[0...len(p)-1]`. Use a sliding window. Add `s[right]`, remove `s[left-1]`. If `windowmap == target_map`, add `left` to result.
17. House Robber
Why you might get asked this:
A classic dynamic programming problem. It teaches how to build solutions by considering choices at each step (rob or not rob) and remembering optimal substructure.
How to answer:
Use dynamic programming. `dp[i]` represents max money robbed up to house `i`. `dp[i] = max(dp[i-1], dp[i-2] + currenthousemoney)`. Optimize space to O(1).
Example answer:
Initialize `rob1 = 0`, `rob2 = 0`. Iterate through `nums` (house values). `temp = max(rob1, rob2 + num)`. Update `rob1 = rob2`, `rob2 = temp`. Return `rob2` at the end. Represents max money if `num` is robbed (`rob2+num`) or not robbed (`rob1`).
18. Climb Stairs
Why you might get asked this:
A simple dynamic programming or Fibonacci-like sequence problem. It demonstrates how to identify overlapping subproblems.
How to answer:
The number of ways to reach step `n` is the sum of ways to reach `n-1` (take 1 step) and `n-2` (take 2 steps). This forms a Fibonacci sequence.
Example answer:
Initialize `dp[0]=1`, `dp[1]=1`. For `i` from `2` to `n`, `dp[i] = dp[i-1] + dp[i-2]`. Return `dp[n]`. Can be optimized to O(1) space by only storing the previous two values.
19. Subtree of Another Tree
Why you might get asked this:
Tests tree traversal and subtree comparison. Requires comparing trees for structural and value equality.
How to answer:
Traverse the larger tree (DFS/BFS). At each node, check if the subtree rooted at this node is identical to the smaller tree. A helper function can compare two trees.
Example answer:
Define `issame(p, q)` to check if two trees are identical. In `isSubtree(root, subRoot)`, if `root` is `None`, return `False`. If `issame(root, subRoot)` is `True`, return `True`. Else, return `isSubtree(root.left, subRoot) or isSubtree(root.right, subRoot)`.
20. Binary Tree Level Order Traversal
Why you might get asked this:
A fundamental BFS (Breadth-First Search) problem. Tests your understanding of queue data structure for level-by-level traversal.
How to answer:
Use a queue. Add the root. While the queue is not empty, process all nodes at the current level, adding their children to the queue for the next level.
Example answer:
Initialize `result` list and `queue` with `[root]`. While `queue` is not empty, get current level size. Process nodes one by one for this level, adding their values to a `levelnodes` list and their children to `queue`. Append `levelnodes` to `result`.
21. Symmetric Tree
Why you might get asked this:
Tests recursive tree traversal with a twist: comparing left and right subtrees symmetrically. Often solved with a helper function.
How to answer:
Define a helper function that takes two nodes (left and right) and checks if they are mirror images of each other. Recursively call for `left.left` with `right.right` and `left.right` with `right.left`.
Example answer:
Define `ismirror(node1, node2)`. If both are `None`, return `True`. If one is `None` or values differ, return `False`. Else, return `node1.val == node2.val` AND `ismirror(node1.left, node2.right)` AND `ismirror(node1.right, node2.left)`. Call `ismirror(root.left, root.right)`.
22. Path Sum
Why you might get asked this:
A basic tree traversal problem testing recursion and target sum tracking. Explores paths from root to leaf.
How to answer:
Recursively traverse the tree. Subtract the current node's value from the `targetSum`. If it's a leaf node and `targetSum` becomes zero, a path exists.
Example answer:
Define `haspath(node, currentsum)`. If `node` is `None`, return `False`. Update `currentsum -= node.val`. If `node` is a leaf and `currentsum == 0`, return `True`. Else, return `haspath(node.left, currentsum) or haspath(node.right, currentsum)`.
23. Convert Sorted Array to Binary Search Tree
Why you might get asked this:
Tests your understanding of BST properties and recursion for balancing trees. It's about efficiently constructing a balanced BST from sorted data.
How to answer:
Recursively select the middle element of the array as the root. Recursively build the left subtree from the left half and the right subtree from the right half.
Example answer:
Define a recursive helper `buildbst(left, right)`. If `left > right`, return `None`. Calculate `mid = (left + right) // 2`. Create a `TreeNode` with `nums[mid]`. Set `node.left = buildbst(left, mid - 1)` and `node.right = build_bst(mid + 1, right)`. Return `node`.
24. Implement Trie (Prefix Tree)
Why you might get asked this:
Tests data structure design and implementation for efficient prefix-based searching. Useful for autocomplete and spell checkers.
How to answer:
Implement a `TrieNode` class with children (dictionary/array) and an `isendof_word` flag. Implement `insert`, `search`, and `startsWith` methods using these nodes.
Example answer:
A `TrieNode` has a `children` dictionary mapping characters to `TrieNode`s and a `isend` boolean. `insert` traverses, adding new nodes as needed. `search` traverses, checking `isend`. `startsWith` traverses to prefix end, not requiring `is_end`.
25. Search in Rotated Sorted Array
Why you might get asked this:
A challenging binary search variant. Tests your ability to adapt standard algorithms to handle unusual constraints (rotation point).
How to answer:
Use modified binary search. Determine which half of the array is sorted. If `target` falls within the sorted half, search there. Otherwise, search the unsorted half.
Example answer:
In each binary search step, identify if the left or right half is sorted. If `nums[low] <= nums[mid]`, left half is sorted. Check if `target` is in `[nums[low], nums[mid]]`. Adjust `low` or `high` accordingly. Repeat for right half.
26. Median of Two Sorted Arrays
Why you might get asked this:
A hard problem testing advanced binary search or partitioning concepts to find the median in O(log(min(m,n))) time.
How to answer:
Use a binary search approach to find the partition point in the smaller array. Ensure the left halves combined are smaller than the right halves combined, and they have `(m+n+1)/2` elements.
Example answer:
Perform binary search on the shorter array's partition index. Calculate partition for the longer array. Adjust partitions until `maxleftX <= minrightY` and `maxleftY <= minrightX`. Then median is derived from max of lefts and min of rights.
27. Container With Most Water
Why you might get asked this:
A greedy two-pointer problem. Tests optimizing area calculation by strategically moving pointers based on height.
How to answer:
Use two pointers, one at each end of the array. Calculate area. Move the pointer pointing to the shorter line inward, as moving the taller one won't improve area.
Example answer:
Initialize `left = 0`, `right = len(height) - 1`, `maxarea = 0`. While `left < right`: `currentarea = min(height[left], height[right]) * (right - left)`. Update `max_area`. If `height[left] < height[right]`, increment `left`; else, decrement `right`.
28. 3Sum
Why you might get asked this:
A popular problem combining sorting and two-pointer technique. Tests handling duplicates and finding triplets efficiently.
How to answer:
Sort the array. Iterate with one pointer `i`. Use two pointers (`left`, `right`) for the remaining array to find pairs summing to `0 - nums[i]`. Handle duplicates carefully.
Example answer:
Sort `nums`. Iterate `i` from `0` to `n-3`. Skip duplicates for `nums[i]`. Set `left = i + 1`, `right = n - 1`. While `left < right`: calculate `currentsum`. If `0`, add triplet, then increment `left`/decrement `right` skipping duplicates. Adjust `left`/`right` based on `currentsum` vs 0.
29. Merge Two Sorted Lists
Why you might get asked this:
A basic linked list manipulation problem. Tests your ability to merge two sorted lists into one, maintaining sorted order and pointer management.
How to answer:
Use a dummy head node. Iterate through both lists, appending the smaller current node to the merged list. Handle remaining nodes.
Example answer:
Create a `dummy` node and `current = dummy`. While `l1` and `l2` are not `None`, compare `l1.val` and `l2.val`. Append the smaller node to `current.next` and advance its list pointer. Append remaining list. Return `dummy.next`.
30. Lowest Common Ancestor of a Binary Search Tree
Why you might get asked this:
Tests understanding of BST properties and tree traversal for finding common ancestors efficiently by leveraging the sorted nature of BSTs.
How to answer:
Traverse the BST from the root. If both `p` and `q` are on one side of the current node (e.g., both smaller), move there. If they are on different sides or one is the current node, current node is LCA.
Example answer:
Initialize `current = root`. While `current` is not `None`: if `p.val < current.val` and `q.val < current.val`, set `current = current.left`. If `p.val > current.val` and `q.val > current.val`, set `current = current.right`. Else, return `current`.
Other Tips to Prepare for a LeetCode Interview
Preparing for a LeetCode interview requires consistency and strategic practice. Master fundamental data structures and algorithms; focus on optimal time and space complexity. Practice consistently, ideally daily, on platforms like LeetCode to build muscle memory and understand patterns. As Donald Knuth advised, "The best programs... work well." Utilize Verve AI Interview Copilot to simulate real interviews, getting instant feedback on your approach and code. Mock interviews are invaluable for refining communication and handling pressure. As the saying goes, "Practice makes good." Verve AI Interview Copilot helps identify weak areas and provides targeted practice. Always articulate your thought process clearly. Explore more at https://vervecopilot.com for tailored interview practice. A structured plan, enhanced by Verve AI Interview Copilot, significantly boosts confidence and performance.
Frequently Asked Questions Q1: How many LeetCode questions should I solve? A1: Aim for 100-150 problems, focusing on diverse patterns and core concepts, not memorization. Quality over quantity is key.
Q2: What programming language is best for LeetCode? A2: Python or Java are popular for their concise syntax and extensive libraries, widely accepted in tech interviews.
Q3: Should I memorize solutions? A3: No, focus on understanding the underlying data structures, algorithms, and thought processes. Memorization hinders problem-solving.
Q4: How do I handle a problem I don't know? A4: Clarify requirements, brainstorm approaches, discuss tradeoffs, and if truly stuck, explain partial solutions or ask for hints.
Q5: What's the "Blind 75"? A5: It's a curated list of 75 common LeetCode problems covering essential topics, highly recommended for interview preparation.
Kent McAllister
Career Advisor
