Sliding Window and Two Pointers: The Two Patterns That Unlock Array Problems

Two Pointers — the core idea

Two pointers uses two indices that move through an array, typically starting at opposite ends (left and right) or both at the start (fast and slow). Instead of checking every possible pair with two nested loops — O(n²) — you move the pointers intelligently based on the current comparison, reducing the solution to O(n).

The key insight: if the input is sorted, you know exactly which direction to move each pointer based on whether the current result is too small or too large. That determinism is what makes O(n) possible.

Variant 1: Opposite-direction pointers (left/right)

Start L at index 0 and R at the last index. Move them toward each other based on the comparison. Stop when they meet or cross.

Two Sum II — sorted array [2, 7, 11, 15], target = 9:

function twoSumSorted(numbers, target) {
  let left = 0;
  let right = numbers.length - 1;

  while (left < right) {
    const sum = numbers[left] + numbers[right];
    if (sum === target) return [left + 1, right + 1]; // 1-indexed
    if (sum < target) left++;   // need a larger value — move L right
    else right--;               // need a smaller value — move R left
  }
  return [];
}

The decision logic is the essence of the pattern: if the sum is too small, move the left pointer right (to pick a larger value). If the sum is too large, move the right pointer left (to pick a smaller value). The sort order guarantees these moves always get closer to the target.

Variant 2: Same-direction pointers (fast/slow)

Both pointers start at the same position but move at different speeds. The classic application is cycle detection in a linked list (Floyd's algorithm): if there's a cycle, the fast pointer will eventually lap the slow one. If there's no cycle, the fast pointer reaches null.

The same-direction variant also appears in problems that require removing duplicates in place, finding the middle of a linked list, or partitioning arrays.

function hasCycle(head) {
  let slow = head;
  let fast = head;

  while (fast !== null && fast.next !== null) {
    slow = slow.next;        // moves 1 step
    fast = fast.next.next;   // moves 2 steps
    if (slow === fast) return true; // they met — cycle exists
  }
  return false; // fast reached the end — no cycle
}

Two Pointers problems, step by step

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

  for (let i = 0; i < nums.length - 2; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue; // skip duplicates
    let left = i + 1;
    let right = nums.length - 1;

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

function maxArea(height) {
  let left = 0;
  let right = height.length - 1;
  let maxWater = 0;

  while (left < right) {
    const width = right - left;
    const water = Math.min(height[left], height[right]) * width;
    maxWater = Math.max(maxWater, water);

    // always move the shorter wall — the greedy decision
    if (height[left] < height[right]) left++;
    else right--;
  }
  return maxWater;
}

Sliding Window — the core idea

A sliding window maintains a contiguous subarray or substring between two pointers. Instead of recomputing the answer for every possible subarray from scratch — O(n²) — you slide the window forward, adding one element on the right and removing one on the left, updating the answer in O(1) per step. Total: O(n).

Think of it as a view through a glass that moves across the array. At each position, you know exactly what entered the view on the right and what left on the left — you never need to recount what's inside.

Variant 1: Fixed-size window

The window always contains exactly k elements. Slide it one position at a time. At each step: add the new right element, remove the old left element, check the answer.

Maximum sum subarray of size 3 — array [2, 1, 5, 1, 3, 2]:

function maxSumSubarrayOfSizeK(arr, k) {
  let windowSum = 0;
  let maxSum = 0;

  // build the first window
  for (let i = 0; i < k; i++) windowSum += arr[i];
  maxSum = windowSum;

  // slide: add right element, remove left element
  for (let right = k; right < arr.length; right++) {
    windowSum += arr[right];          // new element enters the window
    windowSum -= arr[right - k];      // old element leaves the window
    maxSum = Math.max(maxSum, windowSum);
  }
  return maxSum;
}

Variant 2: Variable-size window

The window size adjusts dynamically based on a constraint. The right pointer always expands the window by one. The left pointer shrinks it when the constraint is violated. This is the most common variant in interviews and the one that trips people up.

function longestSubstringWithoutRepeating(s) {
  const seen = new Map(); // tracks last-seen index of each char
  let left = 0;
  let maxLen = 0;

  for (let right = 0; right < s.length; right++) {
    const char = s[right];

    // if char was seen inside the current window, shrink from the left
    if (seen.has(char) && seen.get(char) >= left) {
      left = seen.get(char) + 1; // jump left past the duplicate
    }

    seen.set(char, right);       // record the latest position of char
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

Sliding Window problems, step by step

function checkInclusion(s1, s2) {
  if (s1.length > s2.length) return false;
  const freq1 = new Array(26).fill(0);
  const freq2 = new Array(26).fill(0);
  const a = 'a'.charCodeAt(0);

  for (let i = 0; i < s1.length; i++) {
    freq1[s1.charCodeAt(i) - a]++;
    freq2[s2.charCodeAt(i) - a]++;
  }

  let matches = freq1.filter((v, i) => v === freq2[i]).length;
  if (matches === 26) return true;

  for (let right = s1.length; right < s2.length; right++) {
    const left = right - s1.length;
    // add right character
    const rIdx = s2.charCodeAt(right) - a;
    if (freq2[rIdx] === freq1[rIdx]) matches--;
    freq2[rIdx]++;
    if (freq2[rIdx] === freq1[rIdx]) matches++;
    // remove left character
    const lIdx = s2.charCodeAt(left) - a;
    if (freq2[lIdx] === freq1[lIdx]) matches--;
    freq2[lIdx]--;
    if (freq2[lIdx] === freq1[lIdx]) matches++;

    if (matches === 26) return true;
  }
  return false;
}

function minWindow(s, t) {
  const need = new Map();
  for (const c of t) need.set(c, (need.get(c) ?? 0) + 1);

  let have = 0;
  const required = need.size; // number of unique chars we need
  let left = 0;
  let minLen = Infinity;
  let result = '';

  for (let right = 0; right < s.length; right++) {
    // EXPAND: add right character to window
    const c = s[right];
    if (need.has(c)) {
      need.set(c, need.get(c) - 1);
      if (need.get(c) === 0) have++; // this char is fully satisfied
    }

    // SHRINK: once all chars are covered, move left forward
    while (have === required) {
      if (right - left + 1 < minLen) {
        minLen = right - left + 1;
        result = s.slice(left, right + 1);
      }
      const leftChar = s[left];
      if (need.has(leftChar)) {
        need.set(leftChar, need.get(leftChar) + 1);
        if (need.get(leftChar) > 0) have--; // coverage lost
      }
      left++;
    }
  }
  return result;
}

Two Pointers vs Sliding Window — what's the actual difference?

Here's the thing most guides don't explain clearly: sliding window is a specialized form of two pointers. Both use a left and a right index. The difference is in what they optimize for and how the pointers move.

How to recognize these patterns in an interview

The real skill isn't knowing how to implement two pointers or sliding window — it's recognizing which one applies within the first 2 minutes of reading a problem. Here's the vocabulary that signals each pattern:

Practice reading the problem statement and writing the pattern name before looking at any solution. That 30-second recognition reflex is the skill that transfers directly to interviews — where you have 5 minutes before you're expected to start coding.

How to study these patterns so they stick

1. Learn them visually first. Before writing any code, trace the pointer movements on paper for a small example. Where does L start? Where does R start? When does each one move? Can you predict the next state from the current one? If yes, you understand the pattern. If not, you've memorized the code without the intuition.
2. Code the template, not the problem. Learn the general sliding window template (fixed and variable) and the two-pointer template before solving any specific problem. When the template is solid, each new problem just fills in the details.
3. Solve problems in clusters. Do 4–5 two-pointer problems in a row, then 4–5 sliding window problems. Interleaving different patterns feels productive but produces shallow recognition. Clustering builds the deep pattern-matching that transfers to unfamiliar problems.
4. Write the invariant in words. For every problem you solve, write one sentence: "The window always satisfies X" or "The pointers always maintain the property that Y." Saying this out loud in an interview shows structural thinking — not just a working solution.
5. Time yourself. Both patterns should click within 5 minutes of reading the problem. If they don't, the bottleneck is recognition, not implementation — solve more problems in the same cluster without looking at solutions first.

Frequently asked questions

Summary

Two pointers and sliding window are the two patterns that eliminate nested loops for array and string problems. Two pointers works by moving two indices toward each other (or at different speeds) through a sorted array or linked list. Sliding window works by maintaining a contiguous subarray whose size expands and contracts based on a constraint.

The decision framework is straightforward: if the problem involves a contiguous subarray or substring, reach for sliding window. If the array is sorted and you need relationships between pairs of elements, reach for two pointers. If neither is obvious, check whether sorting the input would create a useful property — a strong signal for two pointers.

Both patterns are learnable in a week with focused practice: learn the templates, cluster your problem sets, and train recognition before implementation. At that point, these patterns stop feeling like tricks and start feeling like natural tools.