Sliding Window Maximum

Sliding Window Maximum - Problem

You are given an array of integers nums and a sliding window of size k which moves from the leftmost position to the rightmost position. At each position, you can only see the k numbers in the window.

Each time the sliding window moves right by one position, find the maximum element in the current window.

Return an array containing the maximum value of each window position.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

› Output: [3,3,5,5,6,7]

💡 Note: Window [1,3,-1] → max=3, [3,-1,-3] → max=3, [-1,-3,5] → max=5, [-3,5,3] → max=5, [5,3,6] → max=6, [3,6,7] → max=7

Example 2 — Single Element Window

$ Input: nums = [1], k = 1

› Output: [1]

💡 Note: Only one element, so maximum is itself

Example 3 — All Same Elements

$ Input: nums = [7,7,7,7], k = 2

› Output: [7,7,7]

💡 Note: All elements are same, so every window has maximum 7

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

a Amazon 50 G Google 45 M Microsoft 40 f Facebook 35

The key insight is to avoid recalculating maximums from scratch. The optimal deque approach maintains indices in decreasing order of values, ensuring O(n) time complexity by processing each element at most twice. Time: O(n), Space: O(k).

Common Approaches

✓ Brute Force

⏱️ Time: O(n×k) Space: O(1)

Slide the window one position at a time. For each window position, iterate through all k elements in the current window to find the maximum value. Store each maximum in the result array.

Deque (Monotonic Queue)

⏱️ Time: O(n) Space: O(k)

Maintain a deque that stores indices in decreasing order of their values. The front always contains the index of the maximum element in current window. Remove elements that are out of window and smaller elements that can never be maximum.

Max Heap with Lazy Deletion

⏱️ Time: O(n log k) Space: O(k)

Maintain a max heap containing (value, index) pairs. For each window, add new element to heap and remove elements that are outside current window from the top. The heap top gives us the maximum in current window.

Brute Force — Algorithm Steps

Step 1: Initialize result array
Step 2: For each valid window position (0 to n-k)
Step 3: Find maximum in current k elements
Step 4: Add maximum to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Window Position 0

Scan elements [1,3,-1] to find max = 3

Window Position 1

Scan elements [3,-1,-3] to find max = 3

Continue

Repeat for all window positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* nums, int numsSize, int k, int* returnSize) {
    if (numsSize == 0 || k == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    // Slide window from position 0 to n-k
    for (int i = 0; i <= numsSize - k; i++) {
        // Find maximum in current window [i, i+k-1]
        int windowMax = nums[i];
        for (int j = i + 1; j < i + k; j++) {
            if (nums[j] > windowMax) {
                windowMax = nums[j];
            }
        }
        result[i] = windowMax;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ']') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(nums, numsSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

For each of the (n-k+1) windows, we scan k elements to find maximum

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, excluding output array

✓ Linear Space

850.0K Views

High Frequency

~25 min Avg. Time

8.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler