2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

LeetCode was HARD until I Learned these 15

Patterns
#21 - Patterns to master LeetCode
ASHISH PRATAP SINGH
JUL 21, 2024

1,248 28 97

Having solved more than 1500 LeetCode problems, if there is one thing I have
learned, it’s this:

LeetCode is less about the number of problems you have solved and more abo
how many patterns you know.

Learning patterns enables you to solve a wide variety of problems in lesser time a
helps you quickly identify the right approach to a problem you have never seen b

In this article, I’ll walk you through the 15 most important patterns I learned tha
made my LeetCode journey lot less painful.

https://blog.algomaster.io/p/15-leetcode-patterns 1/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

I’ll share when to use each pattern along with a sample problem and provide link
LeetCode problems you can practice to learn these patterns better.

1. Prefix Sum

Prefix Sum involves preprocessing an array to create a new array where each elem
at index i represents the sum of the array from the start up to i. This allows for
efficient sum queries on subarrays.

Use this pattern when you need to perform multiple sum queries on a subarray o
to calculate cumulative sums.

Sample Problem:
Given an array nums, answer multiple queries about the sum of elements within a
specific range [i, j].

Example:

Input: nums = [1, 2, 3, 4, 5, 6], i = 1, j = 3

Output: 9

Explanation:

https://blog.algomaster.io/p/15-leetcode-patterns 2/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

1. Preprocess the array A to create a prefix sum array: P = [1, 3, 6, 10, 15

21].

2. To find the sum between indices i and j, use the formula: P[j] - P[i-1].

LeetCode Problems:
1. Range Sum Query - Immutable (LeetCode #303)

2. Contiguous Array (LeetCode #525)

3. Subarray Sum Equals K (LeetCode #560)

2. Two Pointers

The Two Pointers pattern involves using two pointers to iterate through an array
list, often used to find pairs or elements that meet specific criteria.

Use this pattern when dealing with sorted arrays or lists where you need to find p
that satisfy a specific condition.

Sample Problem:
Find two numbers in a sorted array that add up to a target value.

https://blog.algomaster.io/p/15-leetcode-patterns 3/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Example:

Input: nums = [1, 2, 3, 4, 6], target = 6

Output: [1, 3]

Explanation:
1. Initialize two pointers, one at the start (left) and one at the end (right) of t
array.

2. Check the sum of the elements at the two pointers.

3. If the sum equals the target, return the indices.

4. If the sum is less than the target, move the left pointer to the right.

5. If the sum is greater than the target, move the right pointer to the left.

LeetCode Problems:
1. Two Sum II - Input Array is Sorted (LeetCode #167)

2. 3Sum (LeetCode #15)

3. Container With Most Water (LeetCode #11)

3. Sliding Window

https://blog.algomaster.io/p/15-leetcode-patterns 4/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

The Sliding Window pattern is used to find a subarray or substring that satisfies
specific condition, optimizing the time complexity by maintaining a window of
elements.

Use this pattern when dealing with problems involving contiguous subarrays or
substrings.

Sample Problem:
Find the maximum sum of a subarray of size k.

Example:

Input: nums = [2, 1, 5, 1, 3, 2], k = 3

Output: 9

Explanation:
1. Start with the sum of the first k elements.

2. Slide the window one element at a time, subtracting the element that goes ou
the window and adding the new element.

https://blog.algomaster.io/p/15-leetcode-patterns 5/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

3. Keep track of the maximum sum encountered.

LeetCode Problems:
1. Maximum Average Subarray I (LeetCode #643)

2. Longest Substring Without Repeating Characters (LeetCode #3)

3. Minimum Window Substring (LeetCode #76)

4. Fast & Slow Pointers

The Fast & Slow Pointers (Tortoise and Hare) pattern is used to detect cycles in li
lists and other similar structures.

Sample Problem:
Detect if a linked list has a cycle.

Explanation:
1. Initialize two pointers, one moving one step at a time (slow) and the other m
two steps at a time (fast).
2. If there is a cycle, the fast pointer will eventually meet the slow pointer.

3. If the fast pointer reaches the end of the list, there is no cycle.

https://blog.algomaster.io/p/15-leetcode-patterns 6/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

LeetCode Problems:
1. Linked List Cycle (LeetCode #141)

2. Happy Number (LeetCode #202)

3. Find the Duplicate Number (LeetCode #287)

Subscribe to receive new articles every week.

Type your email... Subscribe

5. LinkedList In-place Reversal

The In-place Reversal of a LinkedList pattern reverses parts of a linked list witho
using extra space.

Use this pattern when you need to reverse sections of a linked list.

Sample Problem:
Reverse a sublist of a linked list from position m to n.

Example:

https://blog.algomaster.io/p/15-leetcode-patterns 7/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Input: head = [1, 2, 3, 4, 5], m = 2, n = 4

Output: [1, 4, 3, 2, 5]

Explanation:
1. Identify the start and end of the sublist.

2. Reverse the nodes in place by adjusting the pointers.

LeetCode Problems:
1. Reverse Linked List (LeetCode #206)

2. Reverse Linked List II (LeetCode #92)

3. Swap Nodes in Pairs (LeetCode #24)

6. Monotonic Stack

The Monotonic Stack pattern uses a stack to maintain a sequence of elements in

specific order (increasing or decreasing).

Use this pattern for problems that require finding the next greater or smaller ele

https://blog.algomaster.io/p/15-leetcode-patterns 8/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Sample Problem:
Find the next greater element for each element in an array. Output -1 if the great
element doesn’t exist.

Example:

Input: nums = [2, 1, 2, 4, 3]

Output: [4, 2, 4, -1, -1]

Explanation:
1. Use a stack to keep track of elements for which we haven't found the next gr
element yet.

2. Iterate through the array, and for each element, pop elements from the stack
you find a greater element.

3. If the stack is not empty, set the result for index at the top of the stack to cur
element.

4. Push the current element onto the stack.

LeetCode Problems:
1. Next Greater Element I (LeetCode #496)

2. Daily Temperatures (LeetCode #739)

3. Largest Rectangle in Histogram (LeetCode #84)

7. Top ‘K’ Elements

https://blog.algomaster.io/p/15-leetcode-patterns 9/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

The Top 'K' Elements pattern finds the top k largest or smallest elements in an a
or stream of data using heaps or sorting.

Sample Problem:
Find the k-th largest element in an unsorted array.

Example:

Input: nums = [3, 2, 1, 5, 6, 4], k = 2

Output: 5

Explanation:
1. Use a min-heap of size k to keep track of the k largest elements.

2. Iterate through the array, adding elements to the heap.

3. If the heap size exceeds k, remove the smallest element from the heap.

4. The root of the heap will be the k-th largest element.

LeetCode Problems:
1. Kth Largest Element in an Array (LeetCode #215)

2. Top K Frequent Elements (LeetCode #347)

https://blog.algomaster.io/p/15-leetcode-patterns 10/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

3. Find K Pairs with Smallest Sums (LeetCode #373)

8. Overlapping Intervals

The Overlapping Intervals pattern is used to merge or handle overlapping interv

an array.

In an interval array sorted by start time, two intervals [a, b] and [c, d] overla
>= c (i.e., the end time of the first interval is greater than or equal to the start tim
the second interval).

Sample Problem:
Problem Statement: Merge all overlapping intervals.

Example:

Input: intervals = [[1, 3], [2, 6], [8, 10], [15, 18]]

Output: [[1, 6], [8, 10], [15, 18]]

Explanation:
1. Sort the intervals by their start time.

https://blog.algomaster.io/p/15-leetcode-patterns 11/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

2. Create an empty list called merged to store the merged intervals.

3. Iterate through the intervals and check if it overlaps with the last interval in
merged list.

4. If it overlaps, merge the intervals by updating the end time of the last interva
merged.

5. If it does not overlap, simply add the current interval to the merged list.

LeetCode Problems:
1. Merge Intervals (LeetCode #56)

2. Insert Interval (LeetCode #57)

3. Non-Overlapping Intervals (LeetCode #435)

9. Modified Binary Search

The Modified Binary Search pattern adapts binary search to solve a wider range
problems, such as finding elements in rotated sorted arrays.

Use this pattern for problems involving sorted or rotated arrays where you need t
a specific element.

Sample Problem:

https://blog.algomaster.io/p/15-leetcode-patterns 12/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Find an element in a rotated sorted array.

Example:

Input: nums = [4, 5, 6, 7, 0, 1, 2], target = 0

Output: 4

Explanation:
1. Perform binary search with an additional check to determine which half of t
array is sorted.

2. We then check if the target is within the range of the sorted half.

3. If it is, we search that half; otherwise, we search the other half.

LeetCode Problems:
1. Search in Rotated Sorted Array (LeetCode #33)

2. Find Minimum in Rotated Sorted Array (LeetCode #153)

3. Search a 2D Matrix II (LeetCode #240)

10. Binary Tree Traversal

Binary Tree Traversal involves visiting all the nodes in a binary tree in a specific

https://blog.algomaster.io/p/15-leetcode-patterns 13/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

PreOrder: root -> left -> right

InOrder: left -> root -> right

PostOrder: left -> right -> root

Sample Problem:
Problem Statement: Perform inorder traversal of a binary tree.

Example:

Input: root = [1, null, 2, 3]

Output: [1, 3, 2]

Explanation:
1. Inorder traversal visits nodes in the order: left, root, right.

2. Use recursion or a stack to traverse the tree in this order.

LeetCode Problems:
1. PreOrder → Binary Tree Paths (LeetCode #257)

2. InOrder → Kth Smallest Element in a BST (LeetCode #230)

3. PostOrder → Binary Tree Maximum Path Sum (LeetCode #124)

11. Depth-First Search (DFS)

https://blog.algomaster.io/p/15-leetcode-patterns 14/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Depth-First Search (DFS) is a traversal technique that explores as far down a bran
possible before backtracking.

Use this pattern for exploring all paths or branches in graphs or trees.

Sample Problem:
Find all paths from the root to leaves in a binary tree.

Example:

Input: root = [1, 2, 3, null, 5]

Output: ["1->2->5", "1->3"]

Explanation:
1. Use recursion or a stack to traverse each path from the root to the leaves.

2. Record each path as you traverse.

LeetCode Problems:
1. Clone Graph (LeetCode #133)

2. Path Sum II (LeetCode #113)

3. Course Schedule II (LeetCode #210)

https://blog.algomaster.io/p/15-leetcode-patterns 15/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

12. Breadth-First Search (BFS)

Breadth-First Search (BFS) is a traversal technique that explores nodes level by le

a tree or graph.

Use this pattern for finding the shortest paths in unweighted graphs or level-ord
traversal in trees.

Sample Problem:
Perform level-order traversal of a binary tree.

Example:

Input: root = [3, 9, 20, null, null, 15, 7]

Output: [[3], [9, 20], [15, 7]]

Explanation:
1. Use a queue to keep track of nodes at each level.

2. Traverse each level and add the children of the current nodes to the queue.

LeetCode Problems:
1. Binary Tree Level Order Traversal (LeetCode #102)

https://blog.algomaster.io/p/15-leetcode-patterns 16/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

2. Rotting Oranges (LeetCode #994)

3. Word Ladder (LeetCode #127)

13. Matrix Traversal

Matrix Traversal involves traversing elements in a matrix using different techniq

(DFS, BFS, etc.).

Use this pattern for problems involving traversing 2D grids or matrices horizont
vertically or diagonally.

Sample Problem:
Perform flood fill on a 2D grid. Change all the cells connected to the starting cell
new color.

Example:

Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, newColor

https://blog.algomaster.io/p/15-leetcode-patterns 17/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Output: [[2,2,2],[2,2,0],[2,0,1]]

Explanation:
1. Use DFS or BFS to traverse the matrix starting from the given cell.

2. Change the color of the connected cells to the new color.

LeetCode Problems:
1. Flood Fill (LeetCode #733)

2. Number of Islands (LeetCode #200)

3. Surrounded Regions (LeetCode #130)

14. Backtracking

Backtracking explores all possible solutions and backtracks when a solution path

Use this pattern when you need to find all (or some) solutions to a problem that
satisfies given constraints. For example: combinatorial problems, such as genera
permutations, combinations, or subsets.

https://blog.algomaster.io/p/15-leetcode-patterns 18/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Sample Problem:
Generate all permutations of a given list of numbers.

Example:

Input: nums = [1, 2, 3]

Output: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]

Explanation:
1. Use recursion to generate permutations.

2. For each element, include it in the current permutation and recursively gene
the remaining permutations.

3. Backtrack when all permutations for a given path are generated.

LeetCode Problems:
1. Permutations (LeetCode #46)

2. Subsets (LeetCode #78)

3. N-Queens (LeetCode #51)

15. Dynamic Programming Patterns

https://blog.algomaster.io/p/15-leetcode-patterns 19/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Dynamic Programming (DP) involves breaking down problems into smaller

subproblems and solving them using a bottom-up or top-down approach.

Use this pattern for problems with overlapping subproblems and optimal substru

DP itself has multiple sub-patterns. Some of the most important ones are:

Fibonacci Numbers

0/1 Knapsack

Longest Common Subsequence (LCS)

Longest Increasing Subsequence (LIS)

Subset Sum

Matrix Chain Multiplication

For more Dynamic Programming Patterns, checkout my other article:

20 Patterns to Master Dynamic Programming

ASHISH PRATAP SINGH · JULY 28, 2024

Read full story

Sample Problem:
Calculate the n-th Fibonacci number.

https://blog.algomaster.io/p/15-leetcode-patterns 20/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Example:

Input: n = 5

Output: 5 (The first five Fibonacci numbers are 0, 1, 1, 2, 3, 5)

Explanation:
1. Use a bottom-up approach to calculate the n-th Fibonacci number.

2. Start with the first two numbers (0 and 1) and iterate to calculate the next nu
like (dp[i] = dp[i - 1] + dp[i - 2]).

LeetCode Problems:
1. Climbing Stairs (LeetCode #70)

2. House Robber (LeetCode #198)

3. Coin Change (LeetCode #322)

4. Longest Common Subsequence (LCS) (LeetCode #1143)

5. Longest Increasing Subsequence (LIS) (LeetCode #322)

6. Partition Equal Subset Sum (LeetCode #416)

Thank you so much for reading.

If you found it valuable, hit a like ❤️ and consider subscribing for more such con
every week.

If you have any questions or suggestions, leave a comment.

This post is public so feel free to share it.

Subscribe for free to receive more such articles

every week.

Type your email... Subscribe

https://blog.algomaster.io/p/15-leetcode-patterns 21/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

Checkout my Youtube channel for more in-depth content.

Follow me on LinkedIn, X and Medium to stay updated.

Checkout my GitHub repositories for free interview preparation resources.

I hope you have a lovely day!

See you soon,

Ashish

1,248 Likes ∙ 97 Restacks

Previous Nex

Discussion about this post

Comments Restacks

Write a comment...

Rahul Kumar Jul 21

Liked by Ashish Pratap Singh

Great Stuff for revision, Can you Please Add more on DP section and Graph section .
LIKE (8) REPLY

2 replies by Ashish Pratap Singh and others

FAISAL MASOOD Aug 18

Liked by Ashish Pratap Singh

Awesome for quick refresh

https://blog.algomaster.io/p/15-leetcode-patterns 22/23
2/17/25, 9:11 PM LeetCode was HARD until I Learned these 15 Patterns

LIKE (2) REPLY

26 more comments...

© 2025 Ashish Pratap Singh ∙ Privacy ∙ Terms ∙ Collection notice

Substack is the home for great culture

https://blog.algomaster.io/p/15-leetcode-patterns 23/23