Two Pointer Approach — The Art of Shrinking Your Search Space

The Two Pointer technique is one of those rare algorithmic tools that feels like cheating once you truly understand it. Problems that look like they need nested loops — O(n²) brute force — suddenly collapse into a single O(n) pass. This article covers everything: the intuition, the patterns, step-by-step walkthroughs, and a map of when to actually use it.

What Is the Two Pointer Technique?

At its core, the two pointer approach uses two index variables (pointers) that traverse a data structure — usually an array or string — simultaneously. Instead of checking every pair of elements with two nested loops, you use the positions of these two pointers cleverly so that you only ever do one pass through the data.

The key insight is that in many problems, you can eliminate large chunks of the search space based on a comparison between what the pointers currently point at. This is why the approach is so powerful.

The Three Main Flavors

Example 1 — Two Sum in a Sorted Array

Problem: Given a sorted array and a target number, find two elements that add up to the target. Return their indices (1-indexed).

Array: [2, 7, 11, 15]  |  Target: 9

• Calculate sum = arr[L] + arr[R]
• If sum == target → found it ✅
• If sum < target → move L right
• If sum > target → move R left

Python Code — Two Sum (Sorted)

def two_sum_sorted(nums, target):
    left = 0
    right = len(nums) - 1

    while left < right:
        current_sum = nums[left] + nums[right]

        if current_sum == target:
            return [left + 1, right + 1]
        elif current_sum < target:
            left += 1
        else:
            right -= 1

    return []

nums = [2, 7, 11, 15]
target = 9
print(two_sum_sorted(nums, target))  # Output: [1, 2]

Example 2 — Valid Palindrome

Problem: Given a string, check whether it reads the same forwards and backwards (ignoring non-alphanumeric characters and case).

Input: "A man, a plan, a canal: Panama" → Output: True

def is_palindrome(s):
    left = 0
    right = len(s) - 1

    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1

        if s[left].lower() != s[right].lower():
            return False

        left += 1
        right -= 1

    return True

print(is_palindrome("A man, a plan, a canal: Panama"))  # True
print(is_palindrome("race a car"))                       # False

Example 3 — Remove Duplicates from Sorted Array

Problem: Given a sorted array, remove duplicates in-place so that each element appears only once. Return the new length.

def remove_duplicates(nums):
    if not nums:
        return 0

    slow = 0

    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]

    return slow + 1

nums = [1, 1, 2, 3, 3, 3, 4, 5, 5]
k = remove_duplicates(nums)
print(k)         # 5
print(nums[:k])  # [1, 2, 3, 4, 5]

Example 4 — Container With Most Water

Problem: Given an array height, find two lines that form a container holding the most water.

Key insight: Area = min(height[L], height[R]) × (R - L). Move the shorter side inward.

def max_water(height):
    left = 0
    right = len(height) - 1
    max_area = 0

    while left < right:
        width = right - left
        current_height = min(height[left], height[right])
        area = width * current_height
        max_area = max(max_area, area)

        if height[left] < height[right]:
            left += 1
        else:
            right -= 1

    return max_area

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
print(max_water(height))  # Output: 49

When to Apply the Two Pointer Technique

• The input is sorted (or can be sorted) — Sorted order lets you make intelligent decisions about which pointer to move.
• You need to find a pair or triplet satisfying a condition — Two Sum, Three Sum, pair with max product.
• You need to check a symmetry property — Palindromes, balanced strings.
• You need to partition or filter in-place — Moving zeros, removing duplicates.
• You're optimizing a window or range — Container With Most Water, trapping rainwater.
• You're dealing with a linked list cycle — Fast/slow pointer finds cycles in O(1) space.
• You're merging two sorted arrays — One pointer per array.

Bonus — 3Sum (Extending Two Pointers)

def three_sum(nums):
    nums.sort()
    result = []

    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        left = i + 1
        right = len(nums) - 1

        while left < right:
            total = nums[i] + nums[left] + nums[right]

            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1

    return result

nums = [-1, 0, 1, 2, -1, -4]
print(three_sum(nums))  # [[-1, -1, 2], [-1, 0, 1]]

Common Mistakes to Avoid

Quick Reference — Problems to Practice

Wrapping Up

The two pointer technique is not a magic trick — it's a deliberate reduction of the search space. Every time you move a pointer, you're making a guarantee: "I know for certain this region can't hold a better answer." That guarantee comes from the structure of the data and the property you're searching for.

Once you internalize that idea, you'll start recognizing two-pointer problems on sight. Start with the easy problems in the practice table, implement each one from scratch, and trace through your pointer movements manually on paper at least once. That tactile understanding is what makes the technique click.

Next up: explore the Sliding Window technique — two pointers' close cousin for subarray and substring optimization problems.