CodingPrepGuide.com • Official 1-Page Reference

Top 15 LeetCode Patterns Printable Cheat Sheet

The 15 Algorithmic Patterns that Solve 85% of LeetCode Medium & Hard Questions

🧩

⚡ Quick-Decision Recognition Triggers

› If input array is sorted: Two Pointers or Binary Search (O(log n) or O(n))

› If asked for contiguous subarray/substring maximum or minimum: Sliding Window (O(n))

› If asked for Top K or Kth largest/smallest element: Heap / Priority Queue (O(n log k))

› If asked for combinations, permutations, or all paths: Backtracking (O(2^n) or O(n!))

› If asked to detect cycle or find middle of linked list: Fast & Slow Pointers (O(n) time, O(1) space)

Core Array & Pointer Patterns 1-Page Cheatsheet

1. Two Pointers

Time: O(N) | Space: O(1)

When to use: Sorted array; find pairs meeting a sum or condition; palindrome verification.

Initialize left=0, right=n-1. Move left forward if sum < target, right backward if sum > target.

while l < r:
    s = nums[l] + nums[r]
    if s == target: return [l, r]
    elif s < target: l += 1
    else: r -= 1

2. Sliding Window

Time: O(N) | Space: O(K)

When to use: Contiguous subarray/substring with condition (e.g. longest, shortest, sum <= K).

Expand right pointer to add elements. When constraint violated, contract left pointer until valid again.

for r in range(len(s)):
    window[s[r]] = window.get(s[r], 0) + 1
    while invalid():
        window[s[l]] -= 1
        l += 1
    ans = max(ans, r - l + 1)

3. Fast & Slow Pointers

Time: O(N) | Space: O(1)

When to use: Detect cycle in LinkedList/array; find middle element; happy number.

Slow moves 1 step, Fast moves 2 steps. If they meet, a cycle exists. When fast hits end, slow is at middle.

slow = fast = head
while fast and fast.next:
    slow = slow.next
    fast = fast.next.next
    if slow == fast: return True

4. Prefix Sum

Time: O(N) | Space: O(N)

When to use: Range sum queries; subarrays summing to K in O(1) time.

Prefix sum hash map stores count of seen prefix sums. Look for (current_sum - target) in map.

count = {0: 1}; curr = ans = 0
for x in nums:
    curr += x
    ans += count.get(curr - k, 0)
    count[curr] = count.get(curr, 0) + 1

Heap, Stack & Search Patterns 1-Page Cheatsheet

5. Monotonic Stack

Time: O(N) | Space: O(N)

When to use: Next Greater Element, Daily Temperatures, Largest Rectangle in Histogram.

Stack maintains strictly increasing or decreasing elements. Pop smaller elements when new larger arrives.

stack = []
for i, x in enumerate(nums):
    while stack and nums[stack[-1]] < x:
        res[stack.pop()] = x
    stack.append(i)

6. Top K Elements (Min-Heap)

Time: O(N log K) | Space: O(K)

When to use: Find K largest or smallest elements without sorting entire array.

Maintain a min-heap of size K. If incoming element > heap top, pop and push incoming.

import heapq
heap = []
for x in nums:
    heapq.heappush(heap, x)
    if len(heap) > k: heapq.heappop(heap)

7. Modified Binary Search

Time: O(log N) | Space: O(1)

When to use: Search in rotated sorted array; find peak element; search unknown length.

Determine which half is sorted (nums[l] <= nums[mid]). Check if target lies within the sorted half.

while l <= r:
    mid = (l + r) // 2
    if nums[mid] == target: return mid
    if nums[l] <= nums[mid]: ...

8. Merge Intervals

Time: O(N log N) | Space: O(N)

When to use: Overlapping intervals, calendar bookings, insert interval.

Sort intervals by start time. If current.start <= prev.end, merge by updating prev.end = max(prev.end, current.end).

intervals.sort(key=lambda x: x[0])
merged = [intervals[0]]
for cur in intervals[1:]:
    if cur[0] <= merged[-1][1]: merged[-1][1] = max(merged[-1][1], cur[1])
    else: merged.append(cur)

Graph, Tree & Dynamic Programming 1-Page Cheatsheet

9. Breadth-First Search (BFS)

Time: O(V + E) | Space: O(V)

When to use: Shortest path in unweighted graph/grid; level-order tree traversal.

Use a double-ended queue (deque). Process level by level using `len(q)` batch iteration.

q = collections.deque([(start, 0)])
visited = {start}
while q:
    node, dist = q.popleft()
    for nei in graph[node]: ...

10. Depth-First Search (DFS)

Time: O(V + E) | Space: O(H)

When to use: Count connected components; tree path sums; graph cycle detection.

Traverse recursively or using explicit stack. Mark visited on entry, optionally backtrack on exit.

11. Topological Sort (Kahn's Algorithm)

Time: O(V + E) | Space: O(V)

When to use: Dependency ordering, course scheduling, build systems.

Compute in-degrees for all nodes. Add 0-in-degree nodes to queue. Decrement neighbors as nodes pop.

12. 0/1 Knapsack & Subset DP

Time: O(N * Target) | Space: O(Target)

When to use: Partition equal subset sum; target sum; coin change variations.

1D space optimization: iterate targets backward from Target down to coin value to prevent double-counting.

CodingPrepGuide.com • Free Coding Interview Preparation • No Sign-Up Required