👉👈 Two Pointers Technique

Beginner to Intermediate ~12 min read

You need to find two numbers in a sorted array that sum to a target. The naive approach checks every pair - that's 4,950 comparisons for 100 numbers! The two pointers technique does it in just 100 steps. Let's see how.

The Problem: Two Sum

Given a sorted array, find two numbers that add up to a target value.

Example

Array:  [1, 2, 3, 4, 6, 8, 9]
Target: 10
Answer: indices 2 and 5 (3 + 7 doesn't exist, but 4 + 6 = 10)

Naive approach: Check every pair → O(n²)

Two pointers: Work from both ends → O(n)

How Two Pointers Works

The key insight: In a sorted array, you can eliminate half the search space with each comparison.

The Algorithm

Start with left = 0, right = n-1
Calculate sum = arr[left] + arr[right]
If sum == target: Found it! ✅
If sum < target: Move left++ (need larger sum)
If sum > target: Move right-- (need smaller sum)
Repeat until left >= right

See It in Action

The Code

# Two Pointers Technique - The Essential Pattern
# Solve array problems in O(n) instead of O(n²)

print("=== Problem: Two Sum (Sorted Array) ===")
print("Find two numbers that sum to a target\n")

def two_sum_naive(arr, target):
    """Naive approach: Check every pair - O(n²)"""
    n = len(arr)
    comparisons = 0
    
    for i in range(n):
        for j in range(i + 1, n):
            comparisons += 1
            if arr[i] + arr[j] == target:
                return [i, j], comparisons
    return None, comparisons

def two_sum_two_pointers(arr, target):
    """Two pointers: Work from both ends - O(n)"""
    left = 0
    right = len(arr) - 1
    comparisons = 0
    
    while left < right:
        comparisons += 1
        current_sum = arr[left] + arr[right]
        
        if current_sum == target:
            return [left, right], comparisons
        elif current_sum < target:
            left += 1  # Need larger sum
        else:
            right -= 1  # Need smaller sum
    
    return None, comparisons

# Test both approaches
arr = [1, 2, 3, 4, 6, 8, 9, 12, 15]
target = 10

print(f"Array: {arr}")
print(f"Target: {target}\n")

# Naive approach
result, comps = two_sum_naive(arr, target)
print(f"❌ Naive O(n²): Found {arr[result[0]]} + {arr[result[1]]} = {target}")
print(f"   Comparisons: {comps}\n")

# Two pointers
result, comps = two_sum_two_pointers(arr, target)
print(f"✅ Two Pointers O(n): Found {arr[result[0]]} + {arr[result[1]]} = {target}")
print(f"   Comparisons: {comps}\n")

print("=== The Pattern ===")
print("1. Start with left = 0, right = n-1")
print("2. If sum < target: move left pointer right (increase sum)")
print("3. If sum > target: move right pointer left (decrease sum)")
print("4. If sum == target: found it!")
print("\n✅ Only works on SORTED arrays!")

Output

Click Run to execute your code

Why it works:

If sum is too small, the only way to increase it is to move left pointer right
If sum is too large, the only way to decrease it is to move right pointer left
This eliminates one element per step → O(n) time!

Quick Quiz

Why does this only work on sorted arrays?

Show answer
Because we rely on the fact that moving left increases the sum and moving right decreases it. This only holds if the array is sorted!
What if the array isn't sorted?

Show answer
Sort it first! Sorting is O(n log n), but that's still better than O(n²) for checking all pairs.

Three Common Patterns

Two pointers isn't just for two sum. Here are the main patterns:

# Two Pointers - Common Patterns
# Master these 3 patterns for interviews

print("=== Pattern 1: Opposite Ends (Two Sum) ===")
def two_sum(arr, target):
    """Start from both ends, move based on sum"""
    left, right = 0, len(arr) - 1
    
    while left < right:
        s = arr[left] + arr[right]
        if s == target:
            return [left, right]
        elif s < target:
            left += 1
        else:
            right -= 1
    return None

arr = [1, 2, 3, 4, 6]
print(f"Find two numbers that sum to 7: {two_sum(arr, 7)}")
print("✅ O(n) time, O(1) space\n")

print("=== Pattern 2: Same Direction (Remove Duplicates) ===")
def remove_duplicates(arr):
    """Keep unique elements, return new length"""
    if not arr:
        return 0
    
    write = 1  # Where to write next unique element
    
    for read in range(1, len(arr)):
        if arr[read] != arr[read - 1]:
            arr[write] = arr[read]
            write += 1
    
    return write

arr = [1, 1, 2, 2, 2, 3, 4, 4, 5]
length = remove_duplicates(arr)
print(f"Original: [1, 1, 2, 2, 2, 3, 4, 4, 5]")
print(f"After:    {arr[:length]}")
print("✅ O(n) time, O(1) space (in-place)\n")

print("=== Pattern 3: Sliding Window (Fixed Size) ===")
def max_sum_subarray(arr, k):
    """Maximum sum of k consecutive elements"""
    if len(arr) < k:
        return None
    
    # Initial window
    window_sum = sum(arr[:k])
    max_sum = window_sum
    
    # Slide the window
    for i in range(k, len(arr)):
        window_sum = window_sum - arr[i - k] + arr[i]
        max_sum = max(max_sum, window_sum)
    
    return max_sum

arr = [2, 1, 5, 1, 3, 2]
print(f"Array: {arr}")
print(f"Max sum of 3 consecutive: {max_sum_subarray(arr, 3)}")
print("✅ O(n) time - slides window instead of recalculating\n")

print("=== When to Use Two Pointers ===")
print("✅ Array is sorted (or can be sorted)")
print("✅ Need to find pairs/triplets")
print("✅ Remove duplicates in-place")
print("✅ Reverse/palindrome checks")
print("✅ Partition problems")

Output

Click Run to execute your code

Pattern	When to Use	Example
Opposite Ends	Sorted array, find pairs/triplets	Two sum, three sum
Same Direction	In-place modifications	Remove duplicates, partition
Sliding Window	Subarrays of fixed/variable size	Max sum subarray, longest substring

When to Use Two Pointers

✅ Use Two Pointers When:

Array is sorted (or can be sorted)
Need to find pairs/triplets that satisfy a condition
Removing duplicates in-place
Reversing or checking palindromes
Partitioning arrays

❌ Don't Use When:

Array can't be sorted (order matters)
Need to preserve original indices
Looking for single elements (use binary search instead)

Common Mistakes

❌ Forgetting to Sort

arr = [3, 1, 4, 2]  # Not sorted!
two_sum(arr, 5)  # Won't work correctly

Fix: arr.sort() first

❌ Wrong Pointer Movement

if sum < target:
    right -= 1  # Wrong! Should be left += 1

Remember: Too small → move left. Too large → move right.

Summary

The 3-Point Two Pointers Guide

Pattern: Start from both ends, move based on comparison
Complexity: O(n) time, O(1) space - much better than O(n²)
Requirement: Array must be sorted (or sortable)

Interview tip: When you see "sorted array" and "find pair", think two pointers!

What's Next?

You've mastered two pointers! Next up: Sliding Window - a variation of two pointers for finding optimal subarrays. It's one of the most powerful patterns for string and array problems.

Practice: Try solving "3Sum" (find three numbers that sum to target) using two pointers. Hint: Fix one number, then use two pointers on the rest!

Previous Array Fundamentals

Next Sliding Window