Array & String Sliding Window Patterns

The plain-language idea

Plenty of "look at every contiguous chunk of the array/string" problems get solved naively by recomputing each chunk from scratch: for every starting position, walk forward and recompute a sum, a count, a set of characters. That redoes an enormous amount of overlapping work — most of two adjacent chunks is identical.

A sliding window keeps two pointers, start and end, marking the current chunk, and instead of recomputing when the window moves, it updates incrementally: add whatever the window just gained, remove whatever it just lost. The window slides instead of restarting.

See it in a real thing: two worked examples

Max sum of any subarray of size k (fixed-size window). Naive: for each starting index, sum the next k elements — O(n·k). Sliding window: compute the first window's sum once, then slide by subtracting the element that leaves and adding the one that enters.

function maxSumSubarray(arr, k) {
  let windowSum = 0;
  for (let i = 0; i < k; i++) windowSum += arr[i];

  let maxSum = windowSum;
  for (let end = k; end < arr.length; end++) {
    windowSum += arr[end] - arr[end - k]; // gain one, lose one
    maxSum = Math.max(maxSum, windowSum);
  }
  return maxSum;
}

maxSumSubarray([2, 1, 5, 1, 3, 2], 3); // 9 → [5, 1, 3]

That's O(n) total — each element is added to windowSum exactly once and subtracted exactly once, no matter how many windows there are.

Longest substring without repeating characters (variable-size window). Here the window's size isn't fixed — it grows while characters stay unique, and shrinks from the left the moment a repeat shows up.

function longestUniqueSubstring(str) {
  const seen = new Map(); // char -> last index it appeared at
  let start = 0;
  let longest = 0;

  for (let end = 0; end < str.length; end++) {
    const char = str[end];
    if (seen.has(char) && seen.get(char) >= start) {
      start = seen.get(char) + 1; // jump start past the repeat
    }
    seen.set(char, end);
    longest = Math.max(longest, end - start + 1);
  }
  return longest;
}

longestUniqueSubstring("abcabcbb"); // 3 → "abc"

end only ever moves forward, and start only ever moves forward — each index is visited a bounded number of times, giving O(n) instead of the O(n²) of checking every substring.

What people usually miss

Watch out

• Recomputing the whole window on every slide. If you're summing or re-scanning the entire window at each step instead of adjusting for just what entered and left, you've written an O(n·k) or O(n²) solution that merely looks like a sliding window.
• Off-by-one on window boundaries. Is end inclusive or exclusive? arr[end - k] in the fixed-size example only works because end starts at k, one past the first window's last index — get that starting point wrong and the subtraction targets the wrong element.
• Treating this as the same thing as two pointers. They're related, but here both pointers move in the same direction and the space between them holds running state you maintain incrementally — not two independent indices searching toward each other from opposite ends, or scanning for a pair.

The genealogy: two pointers, with state in between

This builds directly on the two-pointer idea: instead of pointers moving toward each other from opposite ends, a sliding window's pointers move in the same direction, and the "state" living between them — a running sum, a map of characters seen — is what makes each slide O(1) instead of a re-scan. Same discipline of not redoing overlapping work, applied to a moving range instead of a converging pair.