Sliding Window Technique

Say someone gives you an array. They ask for the biggest sum you can get from any 3 numbers sitting next to each other. The simple idea is to add up every group of 3 and pick the best one. That works. But it does a lot of repeated adding. On a big array it gets slow. The sliding window technique fixes exactly that. It reuses the work you already did instead of adding the same numbers again and again.

📚 What Is a Sliding Window?

A sliding window is just a range of elements you look at together. Think of a small frame placed on top of the array. You keep a sum (or a count) for what sits inside that frame.

Now picture a real window on a train. As the train moves, the view shifts. One new tree comes into view on one side. One old tree leaves the view on the other side. You don’t look at the whole landscape again. You only notice what entered and what left.

The sliding window does the same thing with an array. When the frame moves one step to the right:

• one new element comes in on the right
• one old element goes out on the left
• you add the new one and subtract the old one

So you never rebuild the whole sum. You just adjust it.

🎯 The Problem It Solves

Let’s name the pain first. Say the array is [2, 1, 5, 1, 3, 2] and k = 3. You want the maximum sum of any 3 elements in a row.

The simple approach loops over every starting point. Then it adds k elements each time. That is k additions for every window. If the array has n elements, you get about n windows. Each one costs k work. So the total is O(n*k). When k is large this is slow. You keep adding the same middle elements over and over.

The sliding window does the adding only once. After the first window, every move is just one add and one subtract. That makes the whole thing run in O(n).

🪜 Steps to Find the Maximum Sum Subarray of Size k

Here is the plan in plain steps. We build one starting window first, then we slide. Follow this order in the code.

1. Add up the first k elements. Call this windowSum.
2. Save it as your maxSum so far.
3. Now slide. Move from index k to the end of the array.
4. At each step, add the new element coming in (arr[i]) and subtract the element leaving (arr[i - k]).
5. Compare this new windowSum with maxSum. Keep the bigger one.
6. After the loop ends, maxSum holds the answer.

The trick is in step 4. That one add and one subtract replaces a whole fresh loop.

💻 The Code in 5 Languages

We run it on [2, 1, 5, 1, 3, 2] with k = 3. The best window is [5, 1, 3], which sums to 9.

#include <stdio.h>

// Returns the maximum sum of any subarray of size k
int maxSumWindow(int arr[], int n, int k) {
    // Step 1: sum of the first window
    int windowSum = 0;
    for (int i = 0; i < k; i++) {
        windowSum += arr[i];
    }

    // Step 2: that first sum is our best so far
    int maxSum = windowSum;

    // Step 3-5: slide the window across the rest
    for (int i = k; i < n; i++) {
        windowSum += arr[i] - arr[i - k]; // add new, drop old
        if (windowSum > maxSum) {
            maxSum = windowSum;
        }
    }
    return maxSum;
}

int main() {
    int arr[] = {2, 1, 5, 1, 3, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    printf("Maximum sum of size %d: %d\n", k, maxSumWindow(arr, n, k));
    return 0;
}

Maximum sum of size 3: 9

#include <iostream>
#include <vector>
using namespace std;

// Returns the maximum sum of any subarray of size k
int maxSumWindow(const vector<int>& arr, int k) {
    int n = arr.size();

    // Step 1: sum of the first window
    int windowSum = 0;
    for (int i = 0; i < k; i++) {
        windowSum += arr[i];
    }

    // Step 2: that first sum is our best so far
    int maxSum = windowSum;

    // Step 3-5: slide the window across the rest
    for (int i = k; i < n; i++) {
        windowSum += arr[i] - arr[i - k]; // add new, drop old
        if (windowSum > maxSum) {
            maxSum = windowSum;
        }
    }
    return maxSum;
}

int main() {
    vector<int> arr = {2, 1, 5, 1, 3, 2};
    int k = 3;
    cout << "Maximum sum of size " << k << ": " << maxSumWindow(arr, k) << endl;
    return 0;
}

Maximum sum of size 3: 9

public class MaxSumWindow {

    // Returns the maximum sum of any subarray of size k
    static int maxSumWindow(int[] arr, int k) {
        int n = arr.length;

        // Step 1: sum of the first window
        int windowSum = 0;
        for (int i = 0; i < k; i++) {
            windowSum += arr[i];
        }

        // Step 2: that first sum is our best so far
        int maxSum = windowSum;

        // Step 3-5: slide the window across the rest
        for (int i = k; i < n; i++) {
            windowSum += arr[i] - arr[i - k]; // add new, drop old
            if (windowSum > maxSum) {
                maxSum = windowSum;
            }
        }
        return maxSum;
    }

    public static void main(String[] args) {
        int[] arr = {2, 1, 5, 1, 3, 2};
        int k = 3;
        System.out.println("Maximum sum of size " + k + ": " + maxSumWindow(arr, k));
    }
}

Maximum sum of size 3: 9

def max_sum_window(arr, k):
    # Step 1: sum of the first window
    window_sum = sum(arr[:k])

    # Step 2: that first sum is our best so far
    max_sum = window_sum

    # Step 3-5: slide the window across the rest
    for i in range(k, len(arr)):
        window_sum += arr[i] - arr[i - k]  # add new, drop old
        max_sum = max(max_sum, window_sum)

    return max_sum


arr = [2, 1, 5, 1, 3, 2]
k = 3
print(f"Maximum sum of size {k}: {max_sum_window(arr, k)}")

Maximum sum of size 3: 9

function maxSumWindow(arr, k) {
  // Step 1: sum of the first window
  let windowSum = 0;
  for (let i = 0; i < k; i++) {
    windowSum += arr[i];
  }

  // Step 2: that first sum is our best so far
  let maxSum = windowSum;

  // Step 3-5: slide the window across the rest
  for (let i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k]; // add new, drop old
    maxSum = Math.max(maxSum, windowSum);
  }

  return maxSum;
}

const arr = [2, 1, 5, 1, 3, 2];
const k = 3;
console.log(`Maximum sum of size ${k}: ${maxSumWindow(arr, k)}`);

Maximum sum of size 3: 9

🔍 Watching the Window Move

Let’s trace it on [2, 1, 5, 1, 3, 2] with k = 3. This way you can see what happens at each slide.

Here is the same trace as a table. Notice we never re-add the full window. We only adjust by the element entering and the element leaving.

The biggest sum we saw was 9, from the window [5, 1, 3]. That’s the answer.

⏱️ Time and Space Complexity

The first loop builds the starting window in k steps. The second loop visits each remaining element once. Together that is O(n) work. We only keep a couple of variables, so the extra memory is O(1).

⚠️ Common Mistakes

A few things go wrong the first time. Watch for these.

• Forgetting to build the first window before the slide loop starts. The slide formula only works once you have a real starting sum.
• Subtracting the wrong element. The one leaving is arr[i - k], not arr[i - 1]. Get the index right.
• Starting the slide loop at the wrong index. It must start at i = k, because indices 0 to k - 1 are already inside the first window.
• Not checking that k is not larger than the array length. If k is too big, there is no valid window.

🧩 What You’ve Learned

• ✅ A sliding window is a fixed range of elements you carry across the array, adjusting instead of rebuilding.
• ✅ The slow way recomputes every subarray sum and costs O(n*k).
• ✅ Sliding adds the entering element and subtracts the leaving element, so it costs only O(n).
• ✅ The key line is windowSum += arr[i] - arr[i - k].
• ✅ Fixed window keeps a constant size; variable window grows and shrinks on a condition.
• ✅ Extra space stays at O(1) because you only track a sum and a max.

🚀 What’s Next?

Want to keep going? These two pair well with sliding window:

• Two Pointer Technique
• Prefix Sum Technique