Two Pointers

Step 1 Understand it

Remember it by

Sorted? Start at both ends and walk inwards — each move throws away an impossible answer.

Watch it happen

The idea

Two indexes move through the data at the same time, usually one from each end. Each comparison tells you which pointer can move, so you rule out many answers per step and finish in one pass.

Picture it

flowchart LR
  L["L →"] --- A["sorted array"] --- R["← R"]
  A --> Q{"compare arr[L] and arr[R]"}
  Q -->|"too small"| ML["move L right"]
  Q -->|"too big"| MR["move R left"]
  Q -->|"just right"| D["answer ✓"]

Analogy

Finding two friends whose heights add to 3 metres in a line sorted by height. Too short in total? Swap the shortest for the next one up. Too tall? Swap the tallest for the next one down.

Where the analogy breaks

With friends you could just look around. The trick only works because the order is known: moving a pointer is safe only when sorting guarantees everything you skip is worse.

Step 2 Recognise it

Words that signal it

• The input is sorted (or sorting it is allowed)
• 'Pair / triplet that sums to…' in a sorted array
• 'Palindrome', 'reverse in place'
• 'Container', 'trapping water' — two walls that limit each other
• They ask for O(1) extra space

Don't confuse it with

• Sliding Window: Window = a contiguous range where both pointers move the same way. Two pointers here = opposite ends moving towards each other.
• Arrays & Hashing: Unsorted and you can't sort (you need original indexes)? Use a hash map instead.

Gut check

Sorted, and I'm comparing a pair from both ends? → two pointers.

How to recognise it in an interview

The array is explicitly SORTED, or you need to find a combination of elements at opposite ends.

Step 3 The template

The general shape. Adapt it to each problem rather than learning one solution per problem.

def solve(arr):
    left, right = 0, len(arr) - 1
    while left < right:
        if ...:            # found what you want
            return ...
        elif ...:          # left side too small / worse
            left += 1
        else:              # right side too big / worse
            right -= 1
    return ...

class Solution {
    public boolean isPalindrome(String s) {
        int left = 0, right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

Common mistakes

• Using left <= right when the two pointers must be different items (it should be left < right).
• In 3Sum, not skipping repeated values, so the same triplet appears twice.
• Moving the wrong pointer in Container With Most Water: always move the shorter wall, because the taller one can't help while the shorter one limits the height.
• Forgetting to actually increment or decrement the pointers inside the loop, causing an infinite loop crash!

Step 4 Watch it run

Two problems, traced step by step exactly as the code runs.

def two_sum_sorted(numbers, target):
    left, right = 0, len(numbers) - 1
    while left < right:
        total = numbers[left] + numbers[right]
        if total == target:
            return [left + 1, right + 1]      # 1-indexed answer
        if total < target:
            left += 1
        else:
            right -= 1
    return []

def max_area(height):
    left, right = 0, len(height) - 1
    best = 0
    while left < right:
        area = min(height[left], height[right]) * (right - left)
        best = max(best, area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return best

Step 5 Practise

Read each question and say the pattern and the trick out loud before you open the answer. Then solve it on LeetCode. Tick a problem once you've solved it on your own: it comes back for review tomorrow, then after 3, 7, 14 and 30 days, then every month, on the DSA page.

Easy

1. Mark "Valid Palindrome" as solved Valid Palindrome Easy

   Decide whether a string reads the same forwards and backwards, ignoring case and non-letters.

   Show answer

   Technique: Two pointers from both ends

   The clue: 'Palindrome' = compare the two ends moving inwards.

   The trick: Skip non-alphanumeric characters with each pointer, compare lower-case letters, move both inwards.

Medium

1. Mark "Two Sum II Input Array Is Sorted" as solved Two Sum II Input Array Is Sorted Medium

   In a sorted array, find the two numbers that add up to a target, using constant extra space.

   Show answer

   Technique: Two pointers from both ends

   The clue: Sorted + a pair + O(1) space.

   The trick: Sum too small → move the left pointer right; too big → move the right pointer left.

2. Mark "3Sum" as solved 3Sum Medium

   Find all unique triplets that add up to zero.

   Show answer

   Technique: Sort + fix one + two pointers

   The clue: A triplet sum is a pair sum (Two Sum II) for every fixed first number.

   The trick: Sort; for each i, run two pointers on the rest for −nums[i]; skip equal neighbours to avoid duplicate triplets.

3. Mark "Container With Most Water" as solved Container With Most Water Medium

   Pick two vertical lines that, with the x-axis, hold the most water.

   Show answer

   Technique: Two pointers, move the shorter wall

   The clue: Two walls limit each other: area = shorter height × distance.

   The trick: Start at both ends and always move the shorter wall; moving the taller one can never help.

Hard

1. Mark "Trapping Rain Water" as solved Trapping Rain Water Hard

   Given bar heights, compute how much rain water is trapped between them.

   Show answer

   Technique: Two pointers with left max and right max

   The clue: Water above a bar depends on the tallest bar on each side.

   The trick: Water at i = min(max left, max right) − height[i]; move the side with the smaller max, since that side is the limit.

What to say in the interview

'Since the array is sorted, we can avoid O(N) extra space by using two pointers from opposite ends.'

Follow-up prep

What if there are duplicates in the sorted array? (You might have to skip them).