What Is LeetCode's "Top 100 Liked Questions" List?
LeetCode's "Top 100 Liked Questions" is a community-curated list generated entirely by user upvotes — not by LeetCode staff, not by any algorithm, but by thousands of engineers who found a specific problem valuable enough to like after solving it. That voting mechanism makes it uniquely signal-rich: every problem on the list earned its place because real engineers — many of them interviewing at or working at top tech companies — considered it worth recommending.
Of LeetCode's 3,000+ problems, the Top 100 Liked Questions account for roughly 70% of all problems that appear in FAANG-level coding interviews — solving them is the highest-ROI use of preparation time. That concentration happens because the same patterns that make a problem satisfying to solve — elegant two-pointer logic, clean graph traversal, insightful DP formulation — are exactly the patterns that interviewers want to probe.
The challenge with the list as presented on LeetCode is that it is unordered except by like count. A Medium graph problem sits next to an Easy array warm-up. A Hard DP sits next to a straightforward binary search. Without a prioritization framework, candidates often grind the list sequentially and burn time on problems that rarely surface in real interviews before reaching the ones that appear constantly.
This guide solves that problem. We have broken the Top 100 into three tiers — Must Solve, High Priority, and Strong Signal — based on reported interview frequency, pattern coverage, and the foundational value each problem provides. Work through the tiers in order and you will cover the highest-ROI problems first.
Tier 1 — Must Solve: The leetcode top 100 Problems That Appear Most in Real Interviews
These 25 problems appear in interview reports with the highest frequency across FAANG and top-tier companies. They cover the foundational patterns — hash maps, two pointers, sliding window, binary search, linked list manipulation, tree traversal, basic DP, and graph BFS/DFS — that form the backbone of 80%+ of coding interview problems. If you only have time to prepare one tier, prepare this one.
Two Sum (Easy) is the most-liked problem on all of LeetCode and the single most commonly cited warm-up in interview reports. Its lesson is not the problem itself but the instinct it builds: before reaching for O(n²) nested loops, ask whether a hash map reduces it to O(n). That instinct recurs in dozens of harder problems.
Merge Intervals (Medium) tests your ability to sort and then do a linear sweep with a running endpoint — a pattern that appears in calendar scheduling, meeting room problems, and any problem involving overlapping ranges. Valid Parentheses (Easy) teaches stack-based matching, which generalizes to expression evaluation, HTML tag validation, and nested structure problems.
LRU Cache (Medium) is the most common system-design-adjacent coding problem in interviews. It requires combining a doubly linked list with a hash map and is asked frequently at companies that value data structure design. Climbing Stairs (Easy) is the canonical DP warm-up — once you see that dp[i] = dp[i-1] + dp[i-2], you have the mental model for all bottom-up DP problems.
- Two Sum — hash map for O(n) complement lookup; the archetypal array + hash map pattern
- Valid Parentheses — stack matching; generalizes to all nested structure problems
- Merge Intervals — sort + linear sweep; appears in scheduling and range problems
- Best Time to Buy and Sell Stock — single-pass min tracking; introduces greedy thinking
- Maximum Subarray — Kadane's algorithm; O(n) DP on arrays
- Climbing Stairs — bottom-up DP foundation; dp[i] = dp[i-1] + dp[i-2]
- Binary Search — canonical template; every binary search variant derives from this
- Reverse Linked List — pointer manipulation foundation; must know iterative and recursive
- Linked List Cycle — fast/slow pointer detection; Floyd's algorithm
- Merge Two Sorted Lists — merge step of merge sort; builds intuition for K-way merge
- Invert Binary Tree — recursive tree manipulation; simplest tree DFS problem
- Maximum Depth of Binary Tree — DFS/BFS on trees; foundation for all tree problems
- Validate Binary Search Tree — in-order traversal + range constraints
- Binary Tree Level Order Traversal — BFS template for trees; level-by-level processing
- Number of Islands — grid DFS/BFS; canonical connected components pattern
- Course Schedule — cycle detection in directed graph; topological sort foundation
- Word Break — DP + dictionary lookup; substring DP pattern
- Coin Change — classic unbounded knapsack DP; bottom-up with dp[0]=0
- Longest Common Subsequence — 2D DP grid; foundation for edit distance and DP on strings
- House Robber — linear DP with skip constraint; dp[i] = max(dp[i-2]+val, dp[i-1])
- Product of Array Except Self — prefix/suffix product without division; O(n) space trick
- Container With Most Water — two pointers from both ends; greedy pointer movement
- LRU Cache — doubly linked list + hash map; most common design-oriented coding problem
- Find Median from Data Stream — two heaps (max-heap + min-heap); streaming statistics
- Longest Substring Without Repeating Characters — sliding window + set; core sliding window template
Top 10 Most Cited Problems in Interview Reports
Based on aggregated interview reports, these 10 problems appear most frequently in real FAANG interviews: Two Sum, LRU Cache, Merge Intervals, Number of Islands, Word Break, Course Schedule, Binary Tree Level Order Traversal, Longest Substring Without Repeating Characters, Coin Change, and Find Median from Data Stream. If your timeline is short, prioritize these 10 above all others.
Tier 2 — High Priority: leetcode top 100 Problems That Separate Strong Candidates
These 25 problems are the difference between a candidate who "can solve LeetCode problems" and one who demonstrates genuine pattern mastery. They require combining multiple techniques — BFS + state tracking, DP on intervals, graph algorithms beyond simple traversal — and signal to interviewers that you understand the underlying mechanics, not just the solution shape.
Trapping Rain Water (Hard) is a deceptively hard problem that has multiple correct approaches: two pointers, prefix max arrays, and a stack. Interviewers love it because the natural brute-force is obvious but inefficient, and reaching O(n) time with O(1) space requires genuine insight. Jump Game II (Medium) introduces greedy interval covering — a technique that appears in task scheduling and coverage problems.
Rotate Image (Medium) and Spiral Matrix (Medium) are asked by companies that want to see clean 2D array manipulation — the ability to reason about indices without off-by-one errors under pressure. Group Anagrams (Medium) reinforces the hash map pattern but requires a non-obvious key: sorted string or character count tuple.
Decode Ways (Medium) and Unique Paths (Medium) are both medium-difficulty DP problems that frequently appear as warm-up DPs before harder DP follow-ups in interviews. Knowing them cold lets you demonstrate DP fluency quickly.
- Trapping Rain Water — two-pointer O(n)/O(1); multiple valid approaches signal deep understanding
- Jump Game / Jump Game II — greedy reachability; O(n) reach tracking
- Rotate Image — in-place matrix rotation; transpose then reverse columns
- Spiral Matrix — in-place boundary traversal; shrink bounds after each direction
- Group Anagrams — hash map with sorted-string key; O(n·k log k) grouping
- Decode Ways — DP on string with conditional transitions; watch for "0" edge cases
- Unique Paths — 2D DP (combinatorics shortcut also valid); foundation for grid DP
- Search in Rotated Sorted Array — modified binary search; identify which half is sorted first
- Find Minimum in Rotated Sorted Array — binary search variant; O(log n)
- Word Search — grid DFS with backtracking; visited set using in-place modification
- Subsets / Subsets II — backtracking template for power set generation
- Permutations — backtracking with swap or used[] array; O(n!) problems
- Combination Sum — backtracking with pruning; allow repeats by not advancing index
- Letter Combinations of a Phone Number — backtracking over string choices
- Minimum Window Substring — sliding window with character frequency map
- Longest Palindromic Substring — expand from center O(n²) or Manacher O(n)
- Palindromic Substrings — expand from center; count all valid centers
- Pacific Atlantic Water Flow — reverse DFS from both oceans; find intersection
- Clone Graph — BFS/DFS with hash map from old node to new node
- Surrounded Regions — DFS from boundary O cells; mark safe, then flip rest
- Rotting Oranges — multi-source BFS from all initial rotten cells
- Longest Increasing Subsequence — DP O(n²) or patience sort O(n log n)
- Edit Distance — 2D DP; dp[i][j] = min of insert/delete/replace
- Maximum Product Subarray — DP tracking both max and min (negatives flip sign)
- Kth Largest Element in an Array — quickselect O(n) average or heap O(n log k)
Tier 3 — Strong Signal: Problems That Test Deep Pattern Mastery
The Top 100 list skews toward Medium difficulty (approximately 60% Medium, 25% Hard, 15% Easy), reflecting the actual distribution of problems in real technical interviews. The Tier 3 problems are where Hard problems are most concentrated. They test whether you can apply advanced techniques — monotonic stacks, segment trees, advanced graph algorithms, and multi-dimensional DP — correctly under pressure.
Serialize and Deserialize Binary Tree (Hard) is asked at major companies as a capstone tree problem — it requires designing a data format and implementing both directions cleanly. Sliding Window Maximum (Hard) uses a monotonic deque to maintain the max of a sliding window in O(n), which is a technique that appears in several Hard problems.
Word Ladder (Hard) is a classic BFS + graph construction problem where the graph is implicit — you build edges on the fly by trying all single-character mutations. It teaches a general technique for BFS on implicitly defined graphs. Alien Dictionary (Hard) requires topological sort from pairwise character ordering constraints.
The Hard DP problems in this tier — Burst Balloons, Regular Expression Matching, Wildcard Matching, and Interleaving String — are less frequently asked in standard interviews but are commonly asked at companies with rigorous DP-focused rounds. Solving them builds the pattern recognition needed to approach any novel DP problem in an interview.
- Serialize and Deserialize Binary Tree — pre-order DFS with null markers; design problem
- Sliding Window Maximum — monotonic deque; O(n) max tracking over window
- Word Ladder — BFS on implicit graph; try all single-char mutations as edges
- Alien Dictionary — topological sort from character ordering in word pairs
- Median of Two Sorted Arrays — binary search on partition; O(log(min(m,n)))
- Regular Expression Matching — 2D DP with "." and "*" transition rules
- Wildcard Matching — 2D DP; "*" matches any sequence including empty
- Burst Balloons — interval DP; think "last balloon to burst" not first
- Interleaving String — 2D DP; dp[i][j] = can form s3[0..i+j] from s1[0..i] + s2[0..j]
- Largest Rectangle in Histogram — monotonic stack; O(n) with left/right boundaries
- Maximal Rectangle — extend histogram DP to 2D grid row by row
- First Missing Positive — cyclic sort / index marking; O(n) time O(1) space
- N-Queens — backtracking with column/diagonal sets; classic constraint satisfaction
- Sudoku Solver — backtracking with constraint sets per row/col/box
- Jump Game III / IV — BFS on reachability graphs from array indices
- Minimum Cost to Connect All Points — Prim's or Kruskal's MST on grid
- Network Delay Time — Dijkstra's shortest path; single source to all nodes
- Cheapest Flights Within K Stops — Bellman-Ford with stop limit; DP on edges
- Critical Connections in a Network — Tarjan's bridge-finding algorithm
- Recover Binary Search Tree — Morris traversal or inorder + swap detection
- Binary Tree Maximum Path Sum — DFS with global max; consider paths through root
- Path Sum II / III — DFS backtracking for root-to-leaf paths; prefix sum for any path
- Flatten Binary Tree to Linked List — Morris-style in-place or recursive right-threading
- Design Twitter — heap merge of per-user tweet lists; OOP + priority queue
- All O(1) Data Structure — doubly linked list of count buckets + two hash maps
How to Study the Top 100 — Pattern Grouping vs Sequential Approach
There are two common approaches to working through the Top 100: sequential (problem 1 to 100 in order) and pattern-grouped (all sliding window problems together, then all DP, etc.). For most candidates, pattern grouping produces faster skill acquisition — but sequential has a role too.
Pattern grouping works because solving five sliding window problems back-to-back forces you to see the shared structure beneath different problem statements. When you practice Longest Substring Without Repeating Characters, Minimum Window Substring, and Sliding Window Maximum in the same session, you build a reusable mental template for the pattern. That template transfers to novel problems in interviews more reliably than problem-by-problem memorization.
Sequential order has value as a second pass. After you have learned each pattern in isolation, working through problems in mixed order simulates interview conditions — you have to recognize which pattern applies before you can apply it. The recognition step is often where candidates struggle in real interviews.
For pacing: solving 5 problems per day with careful review and explanation of your approach (even just talking through it aloud) leads to Top 100 completion in about 20 days. Solving 3 per day takes about 33 days. Do not rush — a problem solved and understood is worth five problems solved and forgotten.
Revisit cadence matters as much as initial completion. Research on spaced repetition shows that reviewing a solved problem at 1 day, 7 days, and 30 day intervals dramatically increases retention compared to solving once and moving on. YeetCode's spaced repetition system automates this scheduling so you revisit problems at exactly the right intervals.
Use Pattern Grouping, Not Sequential Order
Group problems by pattern for initial learning: first solve all Two Pointer problems together, then all Sliding Window, then BFS/DFS, then DP. This builds a reusable mental template per pattern. Use sequential (mixed) order only on your second pass — as interview simulation. Pattern grouping for acquisition, mixed order for recognition practice.
What the Top 100 Tells You About Interview Trends
The composition of the Top 100 is itself a signal about what the industry values. Looking at pattern distribution, approximately 30% of the list involves trees and graphs (DFS, BFS, topological sort), 25% involves dynamic programming, 20% involves array and string manipulation (two pointers, sliding window, prefix sums), 15% involves linked list and design problems, and 10% involves binary search variants.
That distribution closely mirrors data from interview report aggregators: tree/graph problems are the most commonly asked category at FAANG companies, followed by DP. Array problems appear often as warm-ups, while design problems (LRU Cache, Design Twitter, All O(1) Data Structure) appear at companies that value systems thinking.
FAANG companies lean more heavily on Hard problems than mid-tier companies. At Google, Meta, and Amazon, Tier 3 Hard problems (Serialize/Deserialize Binary Tree, Word Ladder, Hard DP) appear more frequently. At Series B/C startups and mid-tier tech companies, Tier 1 and Tier 2 problems account for the vast majority of interview questions.
The Top 100 also reveals what is not asked often: pure mathematics problems, string parsing problems without algorithmic content, and problems requiring knowledge of highly specialized data structures (like suffix arrays or segment trees) are underrepresented. The list is heavily weighted toward problems that test reasoning and pattern application, not memorization of obscure algorithms.
One important trend: DP problems have grown as a share of the Top 100 over time, as companies have found them harder to coach and memorize than graph problems. If you are preparing for a rigorous company, spending extra time on the DP sections of Tier 2 and Tier 3 has the highest marginal return.
Conclusion: Use the leetcode top 100 as Your North Star
The Top 100 Liked Questions list is the best single roadmap for technical interview preparation because it is validated by the community that has actually gone through interviews. Every problem on the list earned its place through real-world signal — not editorial curation, not algorithmic ranking, but the collective judgment of engineers who found it worth recommending.
The tiered approach in this guide makes the list actionable. Start with Tier 1 Must-Solve problems — they cover the foundational patterns and appear constantly in interviews. Move to Tier 2 once you can solve Tier 1 problems without hints. Add Tier 3 problems for depth, particularly if you are targeting companies with rigorous DP and graph rounds.
Do not grind randomly. Random grinding produces familiarity with individual problems but not the pattern recognition that transfers to novel problems in real interviews. Pattern-grouped study followed by mixed-order review is the proven path from "solving problems I have seen" to "solving problems I have not seen."
After completing the Top 100, use spaced repetition to keep your solutions sharp. YeetCode's flashcard system is built specifically for this — it schedules problem reviews at scientifically optimal intervals so you retain your solutions through the full length of a job search without re-solving everything from scratch every week.