What is the Two Pointers pattern?

The Two Pointers pattern is a systematic approach to solving a class of coding interview problems. By recognizing the Two Pointers structure, you can solve problems in optimal time complexity using proven techniques.

When should I use the Two Pointers pattern?

Use the Two Pointers pattern when the problem structure matches its recognition signals — typically when brute force would be O(n²) or worse, and the pattern reduces complexity to O(n).

What is the time complexity of Two Pointers?

The Two Pointers pattern typically runs in O(n) time and uses O(1) space. The exact complexity depends on the specific sub-variant being applied.

Is Two Pointers important for coding interviews?

Yes — the Two Pointers pattern is frequently tested at FAANG companies and competitive engineering interviews. Mastering this pattern gives you a reliable framework to solve many problem variations quickly.

How do I practice the Two Pointers pattern?

Start by studying the pattern's mental model and recognition signals on DSAPatterns, then practice the curated LeetCode problems below in order from Easy to Hard. Aim for pattern recognition before memorizing solutions.

← back to patterns

pattern / EASY

Two Pointers.

Use two references to traverse a data structure

complexity

time

O(n)

space

O(1)

practice questions

browse and solve all 5 pattern questions →

02' — visual

interactive

Sliding window — k = 3

Maximum sum subarray

Window

[0, 2]

Sum

Step

0 / 3

03'

mental
model.

Two pointers move through the data structure based on a condition. Often one starts at the beginning and one at the end, moving toward each other.

Two Pointers is a technique where two pointers iterate through the data structure in tandem, often used to find pairs or compare elements efficiently.

when to use ✓

01Finding pair with target sum in sorted array
02Removing duplicates from sorted array
03Container with most water
043Sum, 4Sum problems

when not ✗

01Unsorted data without preprocessing
02When you need to maintain original order and pointers would break it

04'

recognition signals

Sorted array or linked list

Need to find pairs/triplets with a target sum

Need to compare elements from both ends

In-place operations on array

Opposite ends pointersFast and slow pointersSame direction pointersThree pointers for triplet problems

05'

templates

</>Beginner Template

1# Beginner: Fixed-size sliding window
2def max_sum_k(nums, k):
3    n = len(nums)
4    if n < k:
5        return 0
6    window_sum = sum(nums[:k])
7    max_sum = window_sum
8    for i in range(k, n):
9        window_sum += nums[i] - nums[i - k]
10        max_sum = max(max_sum, window_sum)
11    return max_sum