Two Pointers — The Complete Guide

function oppositeDirection(arr: number[]): Result {
  let left = 0;
  let right = arr.length - 1;

  while (left < right) {
    // Compute something with arr[left] and arr[right]
    const current = compute(arr[left], arr[right]);

    if (current === target) {
      return result;           // found answer
    } else if (current < target) {
      left++;                  // need bigger → move left forward
    } else {
      right--;                 // need smaller → move right backward
    }
  }

  return notFound;
}
// When to use: sorted array + pair search, palindrome, container/area

function sameDirection(arr: number[]): number {
  let slow = 0; // write pointer — marks the "good" portion

  for (let fast = 0; fast < arr.length; fast++) {
    // fast = read pointer, scans every element
    if (shouldKeep(arr[fast])) {
      arr[slow] = arr[fast];   // write to the "good" portion
      slow++;
    }
  }

  return slow; // length of the "good" portion
}
// When to use: remove duplicates, remove element, move zeroes

function twoSequences(arr1: number[], arr2: number[]): Result {
  let i = 0; // pointer for arr1
  let j = 0; // pointer for arr2

  while (i < arr1.length && j < arr2.length) {
    if (arr1[i] < arr2[j]) {
      // process arr1[i]
      i++;
    } else if (arr1[i] > arr2[j]) {
      // process arr2[j]
      j++;
    } else {
      // arr1[i] === arr2[j] — match found
      // process both
      i++;
      j++;
    }
  }

  // Handle remaining elements in either array
  return result;
}
// When to use: merge sorted arrays, intersection, is-subsequence

function threeSum(nums: number[]): number[][] {
  nums.sort((a, b) => a - b);
  const result: number[][] = [];

  for (let i = 0; i < nums.length - 2; i++) {
    // Skip duplicates for the fixed element
    if (i > 0 && nums[i] === nums[i - 1]) continue;

    let left = i + 1;
    let right = nums.length - 1;
    const target = -nums[i]; // we need nums[left] + nums[right] = -nums[i]

    while (left < right) {
      const sum = nums[left] + nums[right];
      if (sum === target) {
        result.push([nums[i], nums[left], nums[right]]);
        // Skip duplicates
        while (left < right && nums[left] === nums[left + 1]) left++;
        while (left < right && nums[right] === nums[right - 1]) right--;
        left++;
        right--;
      } else if (sum < target) {
        left++;
      } else {
        right--;
      }
    }
  }

  return result;
}
// Time: O(n²) — can't do better for 3Sum
// Space: O(1) ignoring output

function sortColors(nums: number[]): void {
  let low = 0, mid = 0, high = nums.length - 1;

  while (mid <= high) {
    if (nums[mid] === 0) {
      [nums[low], nums[mid]] = [nums[mid], nums[low]];
      low++;
      mid++;
    } else if (nums[mid] === 1) {
      mid++;
    } else {
      [nums[mid], nums[high]] = [nums[high], nums[mid]];
      high--;
      // Don't advance mid — the swapped element needs checking
    }
  }
}
// Time: O(n) single pass | Space: O(1)

Array: [1, 8, 6, 2, 5, 4, 8, 3, 7]
Index:  0  1  2  3  4  5  6  7  8

Step 1: L=0(1), R=8(7) → area = min(1,7) × 8 = 8   → move L (1 < 7)
Step 2: L=1(8), R=8(7) → area = min(8,7) × 7 = 49  → move R (7 < 8)  ★ best so far
Step 3: L=1(8), R=7(3) → area = min(8,3) × 6 = 18  → move R (3 < 8)
Step 4: L=1(8), R=6(8) → area = min(8,8) × 5 = 40  → move R (equal, either works)
Step 5: L=1(8), R=5(4) → area = min(8,4) × 4 = 16  → move R (4 < 8)
Step 6: L=1(8), R=4(5) → area = min(8,5) × 3 = 15  → move R (5 < 8)
Step 7: L=1(8), R=3(2) → area = min(8,2) × 2 = 4   → move R (2 < 8)
Step 8: L=1(8), R=2(6) → area = min(8,6) × 1 = 6   → move R (6 < 8)
         L=1, R=1 → L not < R, stop.

Answer: 49 (between index 1 and 8)

Key insight: We always move the SHORTER wall because:
- Area = min(left, right) × width
- Width always decreases by 1
- Moving the taller wall: min can only stay same or decrease → area decreases
- Moving the shorter wall: min might increase → area might increase
So moving the shorter wall is the only move that has a CHANCE of improving.

Array: [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]
Index:  0  1  2  3  4  5  6  7  8  9  10 11

leftMax = 0, rightMax = 0, water = 0

Step 1:  L=0, R=11 | leftMax=0, rightMax=1
         height[L]=0 <= height[R]=1 → process left
         leftMax = max(0, 0) = 0 | water += 0 - 0 = 0 | L++

Step 2:  L=1, R=11 | leftMax=1, rightMax=1
         height[L]=1 <= height[R]=1 → process left
         leftMax = max(0, 1) = 1 | water += 1 - 1 = 0 | L++

Step 3:  L=2, R=11 | leftMax=1, rightMax=1
         height[L]=0 <= height[R]=1 → process left
         leftMax = 1 | water += 1 - 0 = 1 ★ | L++

...continues until L meets R...

Final answer: 6 units of water

The trick: always process the side with the smaller max.
That side's water level is determined — the other side is at least as tall.

Is the data sorted (or can you sort it)?
├── YES → Do you need to find a pair/triplet with a property?
│         ├── YES → Opposite Direction Two Pointers
│         └── NO  → Do you need to remove/rearrange elements in-place?
│                   ├── YES → Same Direction (read/write) Two Pointers
│                   └── NO  → Are you comparing two sorted sequences?
│                             ├── YES → Two Sequences Two Pointers
│                             └── NO  → Consider Binary Search or Sliding Window
└── NO  → Do you need original indices?
          ├── YES → Use Hash Map instead
          └── NO  → Sort first, then apply Two Pointers