// Two Pointers

core idea

Two indices walk the data instead of one. Because each step permanently discards a chunk of the search space — a pair, a prefix, a wall — you check what looks like O(n²) combinations in a single O(n) pass with O(1) extra space. The pattern has three shapes, and interviews use all three:

when to reach for it

• The input is sorted (or sortable without losing anything you need) and the question is about a pair, triple, or range.
• The words “in-place” or “O(1) space” appear anywhere in the problem.
• You are comparing a sequence with itself reversed, or growing outward from a center — palindromes, mirrors, symmetry.
• A brute force would be two nested loops where the inner loop only moves one way.

universal templates

Opposite ends — the shape you will write most often:

public int[] OppositeEnds(int[] sorted, int target)
{
    int left = 0, right = sorted.Length - 1;

    while (left < right)               // strict <: when they meet, no pair remains
    {
        int sum = sorted[left] + sorted[right];
        if (sum == target) return [left, right];

        if (sum < target) left++;      // sorted[left] is too small for *everyone* → discard it
        else right--;                  // sorted[right] is too big for *everyone* → discard it
    }
    return [];                         // no pair exists
}

Same direction (read/write) — the in-place workhorse:

public int Compact(int[] nums)
{
    int write = 0;                             // everything before write is the answer so far
    for (int read = 0; read < nums.Length; read++)
    {
        if (Keep(nums[read]))
            nums[write++] = nums[read];        // claim the slot, then advance
    }
    return write;                              // new logical length
}

Expand from middle — palindromes grow outward:

public (int Start, int Length) ExpandFromCenter(string s, int left, int right)
{
    while (left >= 0 && right < s.Length && s[left] == s[right])
    {
        left--;                        // grow the mirror outward
        right++;
    }
    return (left + 1, right - left - 1);   // we overshot by one on each side
}

Every problem below is one of these three skeletons with a different comparison in the middle.

problems

1. 01Valid PalindromeeasyLC #125▶ interactive

   Mirror pointers from both ends, skipping non-alphanumerics.

2. 02Two Sum II (Sorted Input)easyLC #167▶ interactive

   Opposite-end pointers; each comparison discards a whole set of pairs.

3. 03Remove Duplicates from Sorted ArrayeasyLC #26

   Same-direction read/write pointers — the in-place compaction template.

4. 04Longest Palindromic SubstringmediumLC #5

   Expand from every center — the third pointer shape, on a top-five interview question.

5. 05Container With Most WatermediumLC #11

   Converging pointers with a greedy proof: always move the shorter wall.

6. 063SummediumLC #15

   Sort + outer loop + two pointers, with duplicate-skipping discipline.

7. 07Trapping Rain WaterhardLC #42stretch

   The capstone: converging pointers carrying maxLeft/maxRight invariants.