Sliding Window Maximum - Practice Coding Problems

Sliding Window Maximum - Problem

Imagine you're looking through a sliding window that moves across an array of integers from left to right. Your task is to find the maximum value visible through this window at each position.

Given an array nums and a window size k, the window starts at the leftmost position and slides one position to the right each time until it reaches the end. At each position, you need to identify the largest number currently visible in the window.

Goal: Return an array containing the maximum value for each window position.

Example: For array [1,3,-1,-3,5,3,6,7] with window size k=3:
• Window [1,3,-1] → max = 3
• Window [3,-1,-3] → max = 3
• Window [-1,-3,5] → max = 5
• And so on...

Input & Output

example_1.py — Basic sliding window

$ 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.py — Single element window

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

› Output: [1]

💡 Note: With window size 1, each element is the maximum of its own window

example_3.py — Window equals array size

$ Input: nums = [9,10,9,-7,-4,-8,2,-6], k = 8

› Output: [10]

💡 Note: Single window covering entire array, maximum element is 10

Visualization

Tap to expand

Understanding the Visualization

Camera Setup

Position camera to view first k rooms in the corridor

Smart Monitoring

AI system maintains list of rooms with highest threat levels

Camera Slides

As camera moves, system automatically removes rooms no longer in view

Update Threats

New room enters view, system discards lower threats that can't be maximum

Report Maximum

System instantly reports highest current threat without scanning all rooms

Key Takeaway

🎯 Key Insight: Like a smart security system, the monotonic deque eliminates impossible candidates proactively, ensuring we can always find the maximum threat level instantly without rescanning all zones.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once, resulting in linear time

✓ Linear Growth

Space Complexity

O(k)

Deque stores at most k indices for the current window

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length
The sliding window moves from left to right exactly one position at a time

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 🍎 Apple 25

The optimal approach uses a monotonic deque to maintain potential maximum candidates in decreasing order. This achieves O(n) time complexity by ensuring each element is processed at most twice - once when added and once when removed from the deque.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Deque (Optimal)	O(n)	O(k)	Use a deque to maintain decreasing sequence of potential maximums
Brute Force (Nested Loops)	O(n*k)	O(1)	For each window position, scan all k elements to find the maximum

Monotonic Deque (Optimal) — Algorithm Steps

Initialize a deque to store indices in decreasing order of their values
Process the first window to populate the deque
For each new element: remove indices outside current window from front
Remove indices from back whose values are smaller than current element
Add current element's index to the back
The front of deque gives the maximum for current window

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Deque

Create empty deque to store indices

Remove Outdated

Remove indices outside current window from front

Maintain Order

Remove smaller elements from back to keep decreasing order

Add Current

Add current element's index to back of deque

Extract Maximum

Front of deque contains index of maximum element

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front;
    int rear;
    int size;
    int capacity;
} Deque;

Deque* createDeque(int capacity) {
    Deque* dq = (Deque*)malloc(sizeof(Deque));
    dq->data = (int*)malloc(capacity * sizeof(int));
    dq->front = 0;
    dq->rear = -1;
    dq->size = 0;
    dq->capacity = capacity;
    return dq;
}

void pushBack(Deque* dq, int item) {
    dq->rear = (dq->rear + 1) % dq->capacity;
    dq->data[dq->rear] = item;
    dq->size++;
}

void popBack(Deque* dq) {
    if (dq->size > 0) {
        dq->rear = (dq->rear - 1 + dq->capacity) % dq->capacity;
        dq->size--;
    }
}

void popFront(Deque* dq) {
    if (dq->size > 0) {
        dq->front = (dq->front + 1) % dq->capacity;
        dq->size--;
    }
}

int front(Deque* dq) {
    return dq->data[dq->front];
}

int back(Deque* dq) {
    return dq->data[dq->rear];
}

int isEmpty(Deque* dq) {
    return dq->size == 0;
}

int* maxSlidingWindow(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));
    Deque* dq = createDeque(numsSize);
    int resultIdx = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Remove indices outside current window
        while (!isEmpty(dq) && front(dq) <= i - k) {
            popFront(dq);
        }
        
        // Remove indices whose values are smaller than current
        while (!isEmpty(dq) && nums[back(dq)] <= nums[i]) {
            popBack(dq);
        }
        
        pushBack(dq, i);
        
        // Add result when window is complete
        if (i >= k - 1) {
            result[resultIdx++] = nums[front(dq)];
        }
    }
    
    free(dq->data);
    free(dq);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once, resulting in linear time

✓ Linear Growth

Space Complexity

O(k)

Deque stores at most k indices for the current window

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length
The sliding window moves from left to right exactly one position at a time

89.4K Views

Very High Frequency

~25 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Monotonic Deque (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler