# Common LeetCode Patterns by Top Tech Companies: Essential Algorithms for FAANG Interviews

> Master common LeetCode patterns used by FAANG companies like Google and Meta. Explore essential algorithms with template code in the azl397985856/leetcode repository to ace your technical interviews.

- Repository: [lucifer/leetcode](https://github.com/azl397985856/leetcode)
- Tags: tutorial
- Published: 2026-03-06

---

**Top tech companies including Google, Amazon, Meta, and Netflix consistently interview candidates on ten core algorithmic patterns—Sliding Window, Binary Search, Depth-First Search, Dynamic Programming, and Union-Find—which are comprehensively documented with template code in the `azl397985856/leetcode` repository.**

Technical interviews at FAANG-style companies rely on recurring algorithmic patterns rather than obscure tricks. The open-source repository `azl397985856/leetcode` organizes these common LeetCode patterns by top tech companies in the `thinkings/` directory, providing architectural overviews and production-ready templates. Mastering these patterns is the most efficient path to interview success.

## Why These Patterns Dominate Technical Interviews

Interviewers at leading technology firms use these patterns because they offer **predictability** and **scalability**. Each pattern provides clear time-complexity guarantees—such as **O(n)** for sliding window or **O(log n)** for binary search—which are key evaluation metrics. Real-world systems at these companies handle massive data streams, making these algorithmic techniques directly applicable to production-grade engineering challenges.

## The 10 Essential LeetCode Patterns for Technical Interviews

The following sections detail the highest-frequency patterns encountered in interviews at Google, Amazon, Meta, Apple, and Netflix. Each includes the specific source file path from the repository where the pattern is documented.

### 1. Two-Pointer and Sliding Window

**Core Concept:** Maintain two indices that move in tandem to represent a "window" of elements satisfying a specific condition. This approach reduces nested loops to linear time.

**Why It Matters:** Google, Amazon, and Meta frequently use subarray and substring problems to test a candidate's ability to optimize brute-force solutions to **O(n)** time.

**Repository Source:** [[`thinkings/slide-window.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/slide-window.md)

**Template Implementation (LeetCode 209 – Minimum Size Subarray Sum):**

```python
class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        l = total = 0
        ans = len(nums) + 1
        for r, val in enumerate(nums):
            total += val
            while total >= s:
                ans = min(ans, r - l + 1)
                total -= nums[l]
                l += 1
        return 0 if ans == len(nums) + 1 else ans

```

### 2. Binary Search

**Core Concept:** Repeatedly halve a sorted search space to locate a target or determine an insertion point. Variants include finding the left-most or right-most occurrence and "counting" binary search for answers that can be verified in **O(log n)**.

**Why It Matters:** Google, Apple, and Netflix emphasize this pattern for problems where the answer space is monotonic, testing a candidate's ability to avoid off-by-one errors.

**Repository Source:** [[`thinkings/binary-search-1.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-search-1.md)

**Template Implementation (LeetCode 278 – First Bad Version):**

```python
class Solution:
    def firstBadVersion(self, n: int) -> int:
        lo, hi = 1, n
        while lo < hi:
            mid = lo + (hi - lo) // 2
            if isBadVersion(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo

```

### 3. Depth-First Search and Backtracking

**Core Concept:** Explore all possible solution paths via recursion, pruning invalid states early to reduce the search space. This pattern suits combinatorial search, permutation generation, and subset problems.

**Why It Matters:** Meta and Amazon use backtracking problems to assess a candidate's comfort with recursion and their ability to implement efficient pruning strategies.

**Repository Source:** [[`thinkings/backtrack.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/backtrack.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/backtrack.md)

### 4. Dynamic Programming

**Core Concept:** Break problems into overlapping sub-problems and store intermediate results to avoid redundant computation. This approach works for optimal substructure problems including knapsack, path-finding, and sequence alignment.

**Why It Matters:** Google, Meta, and Microsoft rely heavily on DP to test a candidate's ability to define state transitions and optimize both time and space complexity.

**Repository Source:** [[`thinkings/dynamic-programming.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/dynamic-programming.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)

### 5. Greedy Algorithms

**Core Concept:** Build a solution step-by-step, always selecting the locally optimal choice. This pattern is effective when the greedy-choice property and optimal substructure can be mathematically proven.

**Why It Matters:** Amazon and Apple use greedy problems to evaluate whether candidates can recognize when local optima lead to global optima versus when dynamic programming is required.

**Repository Source:** [[`thinkings/greedy.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/greedy.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/greedy.md)

### 6. Tree Traversals and Binary Tree Patterns

**Core Concept:** Systematic exploration of tree structures using pre-order, in-order, post-order, and level-order traversals. This pattern is frequently applied to BST validation, lowest common ancestor (LCA), and tree serialization problems.

**Why It Matters:** Google and Meta consistently use tree problems to assess fundamental data structure manipulation and recursive thinking.

**Repository Source:** [[`thinkings/binary-tree-traversal.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-tree-traversal.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/binary-tree-traversal.md)

### 7. Graph Algorithms and Union-Find

**Core Concept:** Model problems as nodes and edges, utilizing BFS, DFS, topological sort, Dijkstra's algorithm, and Union-Find (Disjoint Set Union) for connectivity and cycle detection.

**Why It Matters:** Google and Amazon use graph problems to test a candidate's ability to handle complex relationships and optimize connectivity queries.

**Repository Source:** [[`thinkings/union-find.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/union-find.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/union-find.md) and [[`thinkings/graph.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/graph.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/graph.md)

**Template Implementation (Union-Find Cycle Detection):**

```python
class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))

    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]
            x = self.parent[x]
        return x

    def union(self, a, b):
        pa, pb = self.find(a), self.find(b)
        if pa == pb:
            return False          # cycle detected

        self.parent[pa] = pb
        return True

def hasCycle(n, edges):
    uf = UnionFind(n)
    for u, v in edges:
        if not uf.union(u, v):
            return True
    return False

```

### 8. Heap and Priority Queue

**Core Concept:** Maintain a dynamic ordering of elements using min-heaps or max-heaps to efficiently retrieve k-th largest elements, merge sorted sequences, or process events by priority.

**Why It Matters:** Netflix and Meta use heap problems to evaluate a candidate's understanding of partial ordering and efficient data retrieval under constraints.

**Repository Source:** [[`thinkings/heap.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/heap.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/heap.md)

### 9. Monotonic Stack

**Core Concept:** Maintain a stack where elements are monotonic (strictly increasing or decreasing) to solve "next greater element" problems, largest rectangle in histogram, and similar range-query optimizations.

**Why It Matters:** Google and Amazon use monotonic stack problems to test optimization skills for problems that appear to require **O(n²)** time but can be solved in **O(n)**.

**Repository Source:** [[`thinkings/monotone-stack.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/monotone-stack.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/monotone-stack.md)

**Template Implementation (LeetCode 84 – Largest Rectangle in Histogram):**

```python
def largestRectangleArea(heights):
    stack = [-1]
    max_area = 0
    for i, h in enumerate(heights):
        while stack[-1] != -1 and heights[stack[-1]] >= h:
            height = heights[stack.pop()]
            width = i - stack[-1] - 1
            max_area = max(max_area, height * width)
        stack.append(i)
    while stack[-1] != -1:
        height = heights[stack.pop()]
        width = len(heights) - stack[-1] - 1
        max_area = max(max_area, height * width)
    return max_area

```

### 10. Trie and String Manipulation

**Core Concept:** Store strings in a prefix tree (Trie) for efficient retrieval of words with common prefixes, enabling fast autocomplete, spell-checking, and word search implementations.

**Why It Matters:** Meta and Apple use Trie problems to assess string handling efficiency and prefix-based search optimizations.

**Repository Source:** [[`thinkings/trie.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/trie.md)](https://github.com/azl397985856/leetcode/blob/master/thinkings/trie.md)

**Template Implementation (LeetCode 212 – Word Search II):**

```python
class TrieNode:
    def __init__(self):
        self.children = {}
        self.word = None   # stores complete word at leaf

class Solution:
    def findWords(self, board, words):
        root = TrieNode()
        for w in words:
            node = root
            for ch in w:
                node = node.children.setdefault(ch, TrieNode())
            node.word = w

        rows, cols = len(board), len(board[0])
        result = set()

        def dfs(r, c, node):
            ch = board[r][c]
            if ch not in node.children:
                return
            nxt = node.children[ch]
            if nxt.word:
                result.add(nxt.word)
            board[r][c] = '#'
            for dr, dc in [(1,0),(-1,0),(0,1),(0,-1)]:
                nr, nc = r+dr, c+dc
                if 0 <= nr < rows and 0 <= nc < cols and board[nr][nc] != '#':
                    dfs(nr, nc, nxt)
            board[r][c] = ch

        for i in range(rows):
            for j in range(cols):
                dfs(i, j, root)
        return list(result)

```

## How to Navigate the Repository for Interview Preparation

The `azl397985856/leetcode` repository structures its knowledge base to mirror the interview-focused pattern catalogue used by top tech firms. The `thinkings/` directory contains architectural explanations for each pattern, while the `collections/` directory provides curated lists of Easy, Medium, and Hard problems for targeted practice.

To maximize preparation efficiency, study the template code in each `thinkings/` file first, then apply the patterns to the corresponding problem sets in `collections/`. This method ensures you recognize the underlying structure rather than memorizing individual solutions, which is exactly what interviewers at Google, Amazon, and Meta evaluate.

## Summary

- **Ten core patterns**—Sliding Window, Binary Search, DFS/Backtracking, Dynamic Programming, Greedy, Tree Traversals, Graph Algorithms/Union-Find, Heaps, Monotonic Stacks, and Tries—constitute the majority of LeetCode problems asked at FAANG companies.
- The `azl397985856/leetcode` repository documents each pattern in the `thinkings/` directory with architectural overviews and production-ready templates.
- Mastering these patterns allows candidates to reduce time complexity from **O(n²)** to **O(n)** or from **O(n)** to **O(log n)**, which is a primary evaluation metric in technical screens.

## Frequently Asked Questions

### Which LeetCode pattern is most frequently asked at Google?

**Google interviews heavily emphasize Binary Search and Sliding Window patterns**, often combining them with Tree Traversals or Graph Algorithms. Candidates should focus on mastering the "left-most/right-most" binary search variants and variable-size sliding windows documented in [`thinkings/binary-search-1.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/binary-search-1.md) and [`thinkings/slide-window.md`](https://github.com/azl397985856/leetcode/blob/main/thinkings/slide-window.md).

### How do I choose between Dynamic Programming and Greedy approaches?

**Use Greedy when you can prove that a locally optimal choice leads to a globally optimal solution**, typically in interval scheduling or Huffman coding problems. **Use Dynamic Programming when the problem exhibits overlapping sub-problems and optimal substructure** but lacks the greedy-choice property, such as in knapsack or edit distance problems.

### Where can I find practice problems for these specific patterns?

**The `collections/` directory in the `azl397985856/leetcode` repository** contains curated lists of Easy, Medium, and Hard problems organized by pattern type. Additionally, each `thinkings/` file includes a problem list section linking to specific LeetCode questions that exemplify the pattern.

### Are these patterns sufficient for senior engineer interviews at FAANG companies?

**These patterns form the foundational algorithmic knowledge required for senior roles**, but senior interviews also emphasize system design, distributed systems, and the ability to optimize for specific constraints like memory or throughput. However, fluency in these ten patterns is a prerequisite for passing the coding screens at all levels.