Introduction: The LeetCode Mountain
For many developers, mastering coding interview problems feels like looking up at a huge mountain range. With hundreds of problems on platforms like LeetCode, it's easy to feel overwhelmed and lost in a sea of unrelated challenges. The usual approach is to tackle them one by one, hoping that doing so will lead to success.
But what if there was a better way? What if the key wasn't memorizing hundreds of solutions, but understanding a few powerful, interconnected patterns? This article reveals several surprising insights that change how you view common data structures and algorithms. By uncovering these unexpected connections, you can turn the LeetCode mountain from a daunting obstacle into a manageable climb.
Many "New" Patterns Are Just Clever Remixes
One powerful realization is that many complex patterns are just extensions or variations of simpler, more foundational ones. Instead of learning a dozen unrelated topics, focus on a few core ideas and their variations. This greatly lightens the mental load by organizing patterns into logical "family trees."
The Linear Family Tree
This family of patterns grows from a single, straightforward foundation for working with linear data structures like arrays, linked lists, and strings.
* Foundation: Two Pointers. This technique avoids nested loops by using two pointers to traverse a data structure in linear time. It has two main modes:
* Opposite Directions: Pointers start at opposite ends and move inward, perfect for finding pairs in a sorted array that meet a condition, such as summing to a target.
* Same Direction: Often called the "fast and slow pointer" method, this is used for tasks like detecting cycles in a linked list, where one pointer moves faster than the other.
* Extension 1: Sliding Window. This is a focused application of the same-direction Two Pointers pattern. The pointers define a dynamic "window" or range that expands and contracts to meet a condition, such as finding the longest substring without repeating characters.
* Extension 2: Binary Search. Surprisingly, Binary Search is also a form of the opposite-direction Two Pointers pattern. It uses a left and right pointer to represent a search space, repeatedly dividing it in half to narrow down on a target in logarithmic time.
The Recursive Family Tree
This family of patterns relates to traversing non-linear structures or exploring different solution spaces.
* Foundation: Depth-First Search (DFS). This is a core traversal algorithm for non-linear structures. You explore as far as possible down one path before backtracking to explore another. It's often implemented recursively, using the call stack to manage state.
* Extension 1: Backtracking. This is essentially DFS, but with a key difference: while standard DFS traverses a pre-existing tree or graph, backtracking dynamically builds its own "solution tree" as it explores different combinations or orders.
* Extension 2: Top-Down Dynamic Programming. This often-challenging pattern is simply backtracking with an added step of memoization—caching the results of previous function calls to avoid repeating calculations on overlapping subproblems.
Understanding these relationships means that once you grasp a core concept like Two Pointers or DFS, you're halfway to mastering several others.
The Hidden Power of Binary Search
Most developers learn binary search as a way to find a target value in a sorted array of numbers. While that's accurate, this definition only scratches the surface of its power. The real requirement for binary search isn't a sorted list but a consistent pattern of increase or decrease, known as a monotonic function.
Simply put, binary search works on any problem where the search space can be split into a series of "false" values followed by "true" values. Your goal is to find the boundary—the first true.
For example, consider finding the first true in a conceptual list like [false, false, false, true, true]:
1. Check the middle element.
2. If the middle is false, you know the first true must be to the right. Discard the left half.
3. If the middle is true, this is a possible answer, but the first true could be this element or one to its left. Continue searching in the left half.
This reframes binary search from a simple search algorithm into a powerful tool for finding a transition point. A perfect real-world example is the problem Minimum in Rotated Sorted Array. The array isn't sorted, so binary search seems impossible. However, a monotonic condition exists: any element less than the array's last element belongs to the "rotated" part, while any element greater belongs to the original part.
We can reframe this as [false, false, ..., true, true], where true means nums[i] < nums[last]. Suddenly, a complex array problem becomes a simple search for the first true value—a task binary search excels at.
The Counter-intuitive Logic of "Top K" Problems
Whenever you encounter a problem asking for the "top K," "K smallest," or "K largest" items from a collection, think of a heap, also known as a priority queue. But the way you use it can be surprising.
* To find the K largest values, use a Min Heap.
* To find the K smallest values, use a Max Heap.
Let's walk through the logic for finding the 3 smallest values using a Max Heap to understand why this works:
1. Create a Max Heap of size K (3). A Max Heap keeps the largest element at its root.
2. Fill the heap. Add the first 3 elements from your list to the heap. The largest of these three is now at the root.
3. Iterate through the rest of the list. For each new element, compare it to the root of the heap. The root is the largest value among your top 3 smallest candidates.
4. Make a decision. If the new element is smaller than the root, it could be a better candidate for the "3 smallest" set. Remove the root and insert the new, smaller element. If the new element is larger, do nothing because it can't be one of the K smallest.
This method is incredibly efficient. You only need to store K elements in memory. For each new element, you can check the heap's root in O(1) time to see if it's relevant. If it is, the swap operation (a pop and a push) takes only O(log K) time.
A Tree Is Just a Graph Without Cycles
This simple yet profound realization can greatly simplify how you approach a whole category of problems. Since a tree is a more constrained type of graph, the basic traversal algorithms—Breadth-First Search (BFS) and Depth-First Search (DFS)—apply to both.
There is just one key difference to remember:
* When traversing a general graph that might have cycles, you must use a visited set to keep track of nodes you've already processed. This stops you from getting stuck in an infinite loop.
* When traversing a tree, this isn't necessary because the structure guarantees no cycles.
By adopting this mindset, you won't have to learn separate traversal logic for trees and graphs. You can master one set of patterns (BFS and DFS) and apply them to all non-linear data structures, with just a minor adjustment of adding a visited set when cycles are a possibility.
Conclusion: From Memorizing to Recognizing
The key to succeeding in coding interviews and becoming a better problem-solver isn't just about memorizing hundreds of solutions. It's about understanding the underlying patterns and recognizing how they connect, overlap, and build upon each other. By seeing a sliding window as a type of two-pointer problem or top-down dynamic programming as backtracking with a cache, you simplify things and start recognizing solutions instead of trying to recall them.
Now that you see these connections, which problem will you look at differently now?
