Sliding window

Whereas the multiple pointer pattern works by keeping two array indices running at once and comparing their values on each iteration, the sliding window has a running value (the 'window') that is updated at each iteration and which compares itself against its most recent previous value.

This is what makes it 'sliding': the value isn't constant, it changes (or doesn't) based on what it was previously.

Example: maximum sum of sub-array

We create a function that takes an array and a sub-array length n. The objective is to find the maximum value that can be created by summing n elements of the array. It moves through the array, summing by n keeping track of the highest sum value so far and the current sum value. At the end it should return the highest possible sum value.

Here we do this for a sub-array of length 2:

function maxSubarraySum(arr, subArrLength) {
  let maxSum = 0; // Largest sum value so far
  let tempSum = 0; // Current sum value

  //  Establish the first 'maxSum'
  // At the beginning this will just be the sum of the first two array elements
  for (let i = 0; i < subArrLength; i++) {
    maxSum += arr[i];
  }

  // Map temporary sum to maxSum
  // Accordingly, as we have only mapped the first sub-array, the max sum will be the same
  // as the current sum
  tempSum = maxSum;

  // Move through the array one element at a time (`i++`) via a window starting from the element that is equal to `subArrLength`
  // The first sum calculation is already taken care of in the earlier loop and stored in `maxSum`, so we don't have to worry about missing the elements in indices less than subArrLength
  for (let i = subArrLength; i < arr.length; i++) {
    // Temp sum becomes a moveable window value equal to the subtraction of the previous element and the addition of next element in line
    tempSum = tempSum - arr[i - subArrLength] + arr[i];
    // Max sum is redefined as the largest subArrLengthber between the previous highest and the current value of tempSum
    maxSum = Math.max(maxSum, tempSum);
  }
  return maxSum;
}

console.log(maxSubarraySum([100, 200, 300, 400], 2)); // 700

2.2 KiB Raw Blame History

Sliding window

Example: maximum sum of sub-array

2.2 KiB

Raw Blame History