239. Sliding Window Maximum - Explanation

Description

You are given an array of integers nums and an integer k. There is a sliding window of size k that starts at the left edge of the array. The window slides one position to the right until it reaches the right edge of the array.

Return a list that contains the maximum element in the window at each step.

Example 1:

Input: nums = [1,2,1,0,4,2,6], k = 3

Output: [2,2,4,4,6]

Explanation:
Window position            Max
---------------           -----
[1  2  1] 0  4  2  6        2
 1 [2  1  0] 4  2  6        2
 1  2 [1  0  4] 2  6        4
 1  2  1 [0  4  2] 6        4
 1  2  1  0 [4  2  6]       6

Constraints:

1 <= nums.length <= 100,000
-10,000 <= nums[i] <= 10,000
1 <= k <= nums.length

Topics

Recommended Time & Space Complexity

You should aim for a solution as good or better than O(nlogn) time and O(n) space, where n is the size of the input array.

Hint 1

A brute force solution would involve iterating through each window of size k and finding the maximum element within the window by iterating through it. This would be an O(n * k) solution. Can you think of a better way? Maybe think of a data structure that tells the current maximum element of the window in O(1) time.

Hint 2

A heap is the best data structure to use when dealing with maximum or minimum values and it takes O(1) time to get the max or min value. Here, we use a max-heap. But what should we do if the current maximum element is no longer part of the window? Can you think of a different way of adding values to the max-heap?

Hint 3

We process each window by adding elements to the heap along with their indices to track whether the maximum value is still within the current window. As we move from one window to the next, an element may go out of the window but still remain in the max-heap. Is there a way to handle this situation efficiently?

Hint 4

We can ignore those elements that are no longer part of the current window, except when the maximum value is outside the window. In that case, we remove elements from the max-heap until the maximum value belongs to the current window. Why? Because those elements will be eventually removed when the maximum element goes out of the window.

Company Tags

Please upgrade to NeetCode Pro to view company tags.

Prerequisites

Before attempting this problem, you should be comfortable with:

Sliding Window Technique - Understanding how to maintain a fixed-size window while iterating through an array
Deque (Double-Ended Queue) - Efficiently adding/removing elements from both ends in O(1) time
Monotonic Queue - Maintaining elements in sorted order within a queue for range queries
Heap/Priority Queue - Finding maximum/minimum elements efficiently with lazy deletion

1. Brute Force

Intuition

For every possible window of size k, we simply look at all k elements and pick the maximum.
We slide the window one step at a time, and each time we scan all elements inside it to find the max.
This method is very easy to understand but slow, because we repeatedly re-scan many of the same elements.

Algorithm

Create an empty list output to store the maximum of each window.
For each starting index i from 0 to len(nums) - k:
- Set maxi to nums[i].
- Scan all elements from i to i + k - 1 and update maxi.
- Append maxi to output.
Return output after checking all windows.

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        output = []

        for i in range(len(nums) - k + 1):
            maxi = nums[i]
            for j in range(i, i + k):
                maxi = max(maxi, nums[j])
            output.append(maxi)

        return output

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        int[] output = new int[n - k + 1];

        for (int i = 0; i <= n - k; i++) {
            int maxi = nums[i];
            for (int j = i; j < i + k; j++) {
                maxi = Math.max(maxi, nums[j]);
            }
            output[i] = maxi;
        }

        return output;
    }
}

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> output;
        int n = nums.size();

        for (int i = 0; i <= n - k; i++) {
            int maxi = nums[i];
            for (int j = i; j < i + k; j++) {
                maxi = max(maxi, nums[j]);
            }
            output.push_back(maxi);
        }

        return output;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} k
     * @return {number[]}
     */
    maxSlidingWindow(nums, k) {
        let output = [];

        for (let i = 0; i <= nums.length - k; i++) {
            let maxi = nums[i];
            for (let j = i; j < i + k; j++) {
                maxi = Math.max(maxi, nums[j]);
            }
            output.push(maxi);
        }

        return output;
    }
}

public class Solution {
    public int[] MaxSlidingWindow(int[] nums, int k) {
        int n = nums.Length;
        int[] output = new int[n - k + 1];

        for (int i = 0; i <= n - k; i++) {
            int maxi = nums[i];
            for (int j = i; j < i + k; j++) {
                maxi = Math.Max(maxi, nums[j]);
            }
            output[i] = maxi;
        }

        return output;
    }
}

class Solution {
    fun maxSlidingWindow(nums: IntArray, k: Int): IntArray {
        val output = mutableListOf<Int>()

        for (i in 0..nums.size - k) {
            var maxi = nums[i]
            for (j in i until i + k) {
                maxi = maxOf(maxi, nums[j])
            }
            output.add(maxi)
        }

        return output.toIntArray()
    }
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        var output = [Int]()

        for i in 0...(nums.count - k) {
            var maxi = nums[i]
            for j in i..<(i + k) {
                maxi = max(maxi, nums[j])
            }
            output.append(maxi)
        }

        return output
    }
}

impl Solution {
    pub fn max_sliding_window(nums: Vec<i32>, k: i32) -> Vec<i32> {
        let k = k as usize;
        let n = nums.len();
        let mut output = Vec::with_capacity(n - k + 1);

        for i in 0..=n - k {
            let mut maxi = nums[i];
            for j in i..i + k {
                maxi = maxi.max(nums[j]);
            }
            output.push(maxi);
        }

        output
    }
}

Time & Space Complexity

Time complexity: $O(n * k)$
Space complexity:
- $O(1)$ extra space.
- $O(n - k + 1)$ space for the output array.

Where $n$ is the length of the array and $k$ is the size of the window.

2. Segment Tree

Intuition

The brute-force solution recomputes the maximum for every window by scanning all k elements each time, which is slow.
A Segment Tree helps us answer “what is the maximum in this range?” much faster after some preprocessing.

Think of the segment tree as a special structure built on top of the array where:

Each node stores the maximum of a segment (range) of the array.
The root stores the maximum of the whole array.
Its children store the maximum of left half and right half, and so on.

Once we build this tree:

We can query the maximum for any range [L, R] (our sliding window) in O(log n) time.
We just slide the window and ask the segment tree for the max in each range.

So the process is:
build once → query many times efficiently.

Algorithm

Build the Segment Tree
- Start with an array tree big enough to store a full binary tree.
- Place the original elements in the leaves (second half of tree).
- For each internal node, store the maximum of its two children.
- After this step, tree[1] (the root) holds the maximum of the entire array.
Range Maximum Query (Segment Tree query(l, r)):
- Shift l and r to point to the leaves representing those indices.
- While l <= r in the tree:
  - If l is a right child, consider tree[l] in the answer and move l to the next segment.
  - If r is a left child, consider tree[r] in the answer and move r to the previous segment.
  - Move both l and r up one level by dividing by 2.
- Return the maximum found.
Sliding Window using the Segment Tree
- For each window starting at index i (from 0 to n - k):
  - Query the segment tree for the range [i, i + k - 1].
  - Append this maximum to the output list.
Return the output list containing the maximum for each sliding window.

class SegmentTree:
    def __init__(self, N, A):
        self.n = N
        while (self.n & (self.n - 1)) != 0:
            self.n += 1
        self.build(N, A)

    def build(self, N, A):
        self.tree = [float('-inf')] * (2 * self.n)
        for i in range(N):
            self.tree[self.n + i] = A[i]
        for i in range(self.n - 1, 0, -1):
            self.tree[i] = max(self.tree[i << 1], self.tree[i << 1 | 1])

    def query(self, l, r):
        res = float('-inf')
        l += self.n
        r += self.n + 1
        while l < r:
            if l & 1:
                res = max(res, self.tree[l])
                l += 1
            if r & 1:
                r -= 1
                res = max(res, self.tree[r])
            l >>= 1
            r >>= 1
        return res


class Solution:
    def maxSlidingWindow(self, nums, k):
        n = len(nums)
        segTree = SegmentTree(n, nums)
        output = []
        for i in range(n - k + 1):
            output.append(segTree.query(i, i + k - 1))
        return output

class SegmentTree {
    int n;
    int[] tree;

    SegmentTree(int N, int[] A) {
        this.n = N;
        while (Integer.bitCount(n) != 1) {
            n++;
        }
        build(N, A);
    }

    void build(int N, int[] A) {
        tree = new int[2 * n];
        Arrays.fill(tree, Integer.MIN_VALUE);
        for (int i = 0; i < N; i++) {
            tree[n + i] = A[i];
        }
        for (int i = n - 1; i > 0; --i) {
            tree[i] = Math.max(tree[i << 1], tree[i << 1 | 1]);
        }
    }

    int query(int l, int r) {
        int res = Integer.MIN_VALUE;
        for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
            if ((l & 1) == 1) res = Math.max(res, tree[l++]);
            if ((r & 1) == 1) res = Math.max(res, tree[--r]);
        }
        return res;
    }
}

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        SegmentTree segTree = new SegmentTree(n, nums);
        int[] output = new int[n - k + 1];
        for (int i = 0; i <= n - k; i++) {
            output[i] = segTree.query(i, i + k - 1);
        }
        return output;
    }
}

class SegmentTree {
public:
    int n;
    vector<int> tree;

    SegmentTree(int N, vector<int>& A) {
        this->n = N;
        while (__builtin_popcount(n) != 1) {
            n++;
        }
        build(N, A);
    }

    void build(int N, vector<int>& A) {
        tree.resize(2 * n, INT_MIN);
        for (int i = 0; i < N; i++) {
            tree[n + i] = A[i];
        }
        for (int i = n - 1; i > 0; --i) {
            tree[i] = max(tree[i << 1], tree[i << 1 | 1]);
        }
    }

    int query(int l, int r) {
        int res = INT_MIN;
        for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
            if (l & 1) res = max(res, tree[l++]);
            if (r & 1) res = max(res, tree[--r]);
        }
        return res;
    }
};

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        SegmentTree segTree(n, nums);
        vector<int> output;
        for (int i = 0; i <= n - k; i++) {
            output.push_back(segTree.query(i, i + k - 1));
        }
        return output;
    }
};

class SegmentTree {
    /**
     * @constructor
     * @param {number} N
     * @param {number[]} A
     */
    constructor(N, A) {
        this.n = N;
        while ((this.n & (this.n - 1)) !== 0) {
            this.n++;
        }
        this.build(N, A);
    }

    /**
     * @param {number} N
     * @param {number[]} A
     * @return {void}
     */
    build(N, A) {
        this.tree = new Array(2 * this.n).fill(-Infinity);
        for (let i = 0; i < N; i++) {
            this.tree[this.n + i] = A[i];
        }
        for (let i = this.n - 1; i > 0; i--) {
            this.tree[i] = Math.max(this.tree[i << 1], this.tree[(i << 1) | 1]);
        }
    }

    /**
     * @param {number} l
     * @param {number} r
     * @return {number}
     */
    query(l, r) {
        let res = -Infinity;
        l += this.n;
        r += this.n + 1;

        while (l < r) {
            if (l & 1) res = Math.max(res, this.tree[l++]);
            if (r & 1) res = Math.max(res, this.tree[--r]);
            l >>= 1;
            r >>= 1;
        }

        return res;
    }
}

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} k
     * @return {number[]}
     */
    maxSlidingWindow(nums, k) {
        let n = nums.length;
        let segTree = new SegmentTree(n, nums);
        let output = [];

        for (let i = 0; i <= n - k; i++) {
            output.push(segTree.query(i, i + k - 1));
        }

        return output;
    }
}

public class SegmentTree {
    public int n;
    public int[] tree;

    public SegmentTree(int N, int[] A) {
        this.n = N;
        while (System.Numerics.BitOperations.PopCount((uint)n) != 1) {
            n++;
        }
        Build(N, A);
    }

    public void Build(int N, int[] A) {
        tree = new int[2 * n];
        Array.Fill(tree, int.MinValue);
        for (int i = 0; i < N; i++) {
            tree[n + i] = A[i];
        }
        for (int i = n - 1; i > 0; --i) {
            tree[i] = Math.Max(tree[i << 1], tree[i << 1 | 1]);
        }
    }

    public int Query(int l, int r) {
        int res = int.MinValue;
        l += n;
        r += n + 1;
        while (l < r) {
            if ((l & 1) == 1) res = Math.Max(res, tree[l++]);
            if ((r & 1) == 1) res = Math.Max(res, tree[--r]);
            l >>= 1;
            r >>= 1;
        }
        return res;
    }
}

public class Solution {
    public int[] MaxSlidingWindow(int[] nums, int k) {
        int n = nums.Length;
        SegmentTree segTree = new SegmentTree(n, nums);
        int[] output = new int[n - k + 1];
        for (int i = 0; i <= n - k; i++) {
            output[i] = segTree.Query(i, i + k - 1);
        }
        return output;
    }
}

type SegmentTree struct {
    n    int
    tree []int
}

func NewSegmentTree(N int, A []int) *SegmentTree {
    n := N
    for bits.OnesCount(uint(n)) != 1 {
        n++
    }

    st := &SegmentTree{
        n: n,
    }
    st.build(N, A)
    return st
}

func (st *SegmentTree) build(N int, A []int) {
    st.tree = make([]int, 2*st.n)
    for i := range st.tree {
        st.tree[i] = math.MinInt
    }
    for i := 0; i < N; i++ {
        st.tree[st.n+i] = A[i]
    }
    for i := st.n - 1; i > 0; i-- {
        st.tree[i] = max(st.tree[i<<1], st.tree[i<<1|1])
    }
}

func (st *SegmentTree) Query(l, r int) int {
    res := math.MinInt
    l += st.n
    r += st.n + 1

    for l < r {
        if l&1 == 1 {
            res = max(res, st.tree[l])
            l++
        }
        if r&1 == 1 {
            r--
            res = max(res, st.tree[r])
        }
        l >>= 1
        r >>= 1
    }
    return res
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func maxSlidingWindow(nums []int, k int) []int {
    n := len(nums)
    segTree := NewSegmentTree(n, nums)
    output := make([]int, n-k+1)

    for i := 0; i <= n-k; i++ {
        output[i] = segTree.Query(i, i+k-1)
    }

    return output
}

class SegmentTree(N: Int, A: IntArray) {
    private var n: Int = N
    private var tree: IntArray = IntArray(0)

    init {
        var size = N
        while (Integer.bitCount(size) != 1) {
            size++
        }
        n = size
        build(N, A)
    }

    private fun build(N: Int, A: IntArray) {
        tree = IntArray(2 * n)
        tree.fill(Int.MIN_VALUE)
        for (i in 0 until N) {
            tree[n + i] = A[i]
        }
        for (i in n - 1 downTo 1) {
            tree[i] = maxOf(tree[i * 2], tree[i * 2 + 1])
        }
    }

    fun query(l: Int, r: Int): Int {
        var res = Int.MIN_VALUE
        var left = l + n
        var right = r + n + 1

        while (left < right) {
            if (left % 2 == 1) {
                res = maxOf(res, tree[left])
                left++
            }
            if (right % 2 == 1) {
                right--
                res = maxOf(res, tree[right])
            }
            left /= 2
            right /= 2
        }
        return res
    }
}

class Solution {
    fun maxSlidingWindow(nums: IntArray, k: Int): IntArray {
        val n = nums.size
        val segTree = SegmentTree(n, nums)
        val result = IntArray(n - k + 1)
        for (i in 0..n - k) {
            result[i] = segTree.query(i, i + k - 1)
        }
        return result
    }
}

struct SegmentTree {
    n: usize,
    tree: Vec<i32>,
}

impl SegmentTree {
    fn new(size: usize, a: &[i32]) -> Self {
        let mut n = size;
        while n & (n - 1) != 0 {
            n += 1;
        }
        let mut tree = vec![i32::MIN; 2 * n];
        for i in 0..size {
            tree[n + i] = a[i];
        }
        for i in (1..n).rev() {
            tree[i] = tree[i << 1].max(tree[i << 1 | 1]);
        }
        Self { n, tree }
    }

    fn query(&self, l: usize, r: usize) -> i32 {
        let mut res = i32::MIN;
        let mut l = l + self.n;
        let mut r = r + self.n + 1;
        while l < r {
            if l & 1 == 1 {
                res = res.max(self.tree[l]);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                res = res.max(self.tree[r]);
            }
            l >>= 1;
            r >>= 1;
        }
        res
    }
}

impl Solution {
    pub fn max_sliding_window(nums: Vec<i32>, k: i32) -> Vec<i32> {
        let k = k as usize;
        let n = nums.len();
        let seg_tree = SegmentTree::new(n, &nums);
        let mut output = Vec::with_capacity(n - k + 1);
        for i in 0..=n - k {
            output.push(seg_tree.query(i, i + k - 1));
        }
        output
    }
}

Time & Space Complexity

Time complexity: $O(n \log n)$
Space complexity: $O(n)$

3. Heap

Intuition

We want to quickly get the maximum value inside a sliding window that moves across the array.
A max-heap is perfect for this because it always lets us access the largest element instantly.

As we slide the window:

We keep inserting new elements into the heap.
Some old elements will fall out of the left side of the window.
If the largest element in the heap is no longer inside the window, we remove it.
The top of the heap always represents the current maximum for the window.

This way, we efficiently maintain the maximum even as the window moves.

Algorithm

Use a max-heap to store pairs of (value, index) for all elements we encounter.
Expand the window by inserting each new element into the heap.
Once the window size becomes k:
- Remove elements from the heap if their index is outside the current window.
- The top of the heap now gives the maximum for the window.
Add this maximum to the result list.
Continue sliding the window until the end of the array and return all collected maximums.

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        heap = []
        output = []
        for i in range(len(nums)):
            heapq.heappush(heap, (-nums[i], i))
            if i >= k - 1:
                while heap[0][1] <= i - k:
                    heapq.heappop(heap)
                output.append(-heap[0][0])
        return output

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> b[0] - a[0]);
        int[] output = new int[nums.length - k + 1];
        int idx = 0;
        for (int i = 0; i < nums.length; i++) {
            heap.offer(new int[]{nums[i], i});
            if (i >= k - 1) {
                while (heap.peek()[1] <= i - k) {
                    heap.poll();
                }
                output[idx++] = heap.peek()[0];
            }
        }
        return output;
    }
}

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<pair<int, int>> heap;
        vector<int> output;
        for (int i = 0; i < nums.size(); i++) {
            heap.push({nums[i], i});
            if (i >= k - 1) {
                while (heap.top().second <= i - k) {
                    heap.pop();
                }
                output.push_back(heap.top().first);
            }
        }
        return output;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} k
     * @return {number[]}
     */
    maxSlidingWindow(nums, k) {
        const heap = new MaxPriorityQueue((x) => x[0]);
        const output = [];
        const length = nums.length;

        for (let i = 0; i < length; i++) {
            heap.enqueue([nums[i], i]);

            if (i >= k - 1) {
                while (heap.front()[1] <= i - k) {
                    heap.dequeue();
                }
                output.push(heap.front()[0]);
            }
        }

        return output;
    }
}

public class Solution {
    public int[] MaxSlidingWindow(int[] nums, int k) {
        PriorityQueue<(int val, int idx), int> pq = new PriorityQueue<(int val, int idx), int>(
            Comparer<int>.Create((a, b) => b.CompareTo(a))
        );

        int[] output = new int[nums.Length - k + 1];
        int idx = 0;

        for (int i = 0; i < nums.Length; i++) {
            pq.Enqueue((nums[i], i), nums[i]);

            if (i >= k - 1) {
                while (pq.Peek().idx <= i - k) {
                    pq.Dequeue();
                }
                output[idx++] = pq.Peek().val;
            }
        }

        return output;
    }
}

class Solution {
    fun maxSlidingWindow(nums: IntArray, k: Int): IntArray {
        val output = mutableListOf<Int>()
        val heap = PriorityQueue<Pair<Int, Int>>(compareByDescending { it.first })

        for (i in nums.indices) {
            heap.add(Pair(nums[i], i))
            if (i >= k - 1) {
                while (heap.peek().second <= i - k) {
                    heap.poll()
                }
                output.add(heap.peek().first)
            }
        }
        return output.toIntArray()
    }
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        var heap = Heap<Item>()
        var output = [Int]()

        for i in 0..<nums.count {
            heap.insert(Item(num: nums[i], index: i))

            if i >= k - 1 {
                while heap.max!.index <= i - k {
                    heap.removeMax()
                }
                output.append(heap.max!.num)
            }
        }
        return output
    }
}

struct Item: Comparable {
    let num: Int
    let index: Int

    static func < (lhs: Item, rhs: Item) -> Bool {
        return lhs.num < rhs.num
    }
}

impl Solution {
    pub fn max_sliding_window(nums: Vec<i32>, k: i32) -> Vec<i32> {
        let k = k as usize;
        let mut heap = BinaryHeap::new();
        let mut output = Vec::with_capacity(nums.len() - k + 1);

        for i in 0..nums.len() {
            heap.push((nums[i], i));
            if i >= k - 1 {
                while heap.peek().unwrap().1 + k <= i {
                    heap.pop();
                }
                output.push(heap.peek().unwrap().0);
            }
        }

        output
    }
}

Time & Space Complexity

Time complexity: $O(n \log n)$
Space complexity: $O(n)$

4. Dynamic Programming

Intuition

Instead of recalculating the maximum for each sliding window, we can preprocess the array so that every window’s maximum can be answered in O(1) time.

We divide the array into blocks of size k.
Within each block, we build:

a leftMax array: left-to-right maximums inside each block
a rightMax array: right-to-left maximums inside each block

For any sliding window:

its left part falls inside some block, so the maximum for that region is in rightMax[i]
its right part falls inside a block, so the maximum is in leftMax[i + k - 1]

The true window maximum is the larger of those two.
This lets us compute each window's maximum instantly.

Algorithm

Split the array conceptually into blocks of size k.
Build a leftMax array:
- Scan left to right.
- For each block, restart the maximum at the block boundary.
Build a rightMax array:
- Scan right to left.
- For each block, restart the maximum at the block boundary.
For each sliding window of size k:
- The maximum is max(rightMax[window_start], leftMax[window_end]).
Return all computed maximums.

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        leftMax = [0] * n
        rightMax = [0] * n

        leftMax[0] = nums[0]
        rightMax[n - 1] = nums[n - 1]

        for i in range(1, n):
            if i % k == 0:
                leftMax[i] = nums[i]
            else:
                leftMax[i] = max(leftMax[i - 1], nums[i])

            if (n - 1 - i) % k == 0:
                rightMax[n - 1 - i] = nums[n - 1 - i]
            else:
                rightMax[n - 1 - i] = max(rightMax[n - i], nums[n - 1 - i])

        output = [0] * (n - k + 1)

        for i in range(n - k + 1):
            output[i] = max(leftMax[i + k - 1], rightMax[i])

        return output

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        int[] leftMax = new int[n];
        int[] rightMax = new int[n];

        leftMax[0] = nums[0];
        rightMax[n - 1] = nums[n - 1];

        for (int i = 1; i < n; i++) {
            if (i % k == 0) {
                leftMax[i] = nums[i];
            } else {
                leftMax[i] = Math.max(leftMax[i - 1], nums[i]);
            }

            if ((n - 1 - i) % k == 0) {
                rightMax[n - 1 - i] = nums[n - 1 - i];
            } else {
                rightMax[n - 1 - i] = Math.max(rightMax[n - i], nums[n - 1 - i]);
            }
        }

        int[] output = new int[n - k + 1];

        for (int i = 0; i < n - k + 1; i++) {
            output[i] = Math.max(leftMax[i + k - 1], rightMax[i]);
        }

        return output;
    }
}

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> leftMax(n);
        vector<int> rightMax(n);

        leftMax[0] = nums[0];
        rightMax[n - 1] = nums[n - 1];

        for (int i = 1; i < n; i++) {
            if (i % k == 0) {
                leftMax[i] = nums[i];
            } else {
                leftMax[i] = max(leftMax[i - 1], nums[i]);
            }

            if ((n - 1 - i) % k == 0) {
                rightMax[n - 1 - i] = nums[n - 1 - i];
            } else {
                rightMax[n - 1 - i] = max(rightMax[n - i], nums[n - 1 - i]);
            }
        }

        vector<int> output(n - k + 1);

        for (int i = 0; i < n - k + 1; i++) {
            output[i] = max(leftMax[i + k - 1], rightMax[i]);
        }

        return output;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} k
     * @return {number[]}
     */
    maxSlidingWindow(nums, k) {
        const n = nums.length;
        const leftMax = new Array(n);
        const rightMax = new Array(n);

        leftMax[0] = nums[0];
        rightMax[n - 1] = nums[n - 1];

        for (let i = 1; i < n; i++) {
            if (i % k === 0) {
                leftMax[i] = nums[i];
            } else {
                leftMax[i] = Math.max(leftMax[i - 1], nums[i]);
            }

            if ((n - 1 - i) % k === 0) {
                rightMax[n - 1 - i] = nums[n - 1 - i];
            } else {
                rightMax[n - 1 - i] = Math.max(
                    rightMax[n - i],
                    nums[n - 1 - i],
                );
            }
        }

        const output = new Array(n - k + 1);

        for (let i = 0; i < n - k + 1; i++) {
            output[i] = Math.max(leftMax[i + k - 1], rightMax[i]);
        }

        return output;
    }
}

public class Solution {
    public int[] MaxSlidingWindow(int[] nums, int k) {
        int n = nums.Length;
        int[] leftMax = new int[n];
        int[] rightMax = new int[n];

        leftMax[0] = nums[0];
        rightMax[n - 1] = nums[n - 1];

        for (int i = 1; i < n; i++) {
            if (i % k == 0) {
                leftMax[i] = nums[i];
            } else {
                leftMax[i] = Math.Max(leftMax[i - 1], nums[i]);
            }

            if ((n - 1 - i) % k == 0) {
                rightMax[n - 1 - i] = nums[n - 1 - i];
            } else {
                rightMax[n - 1 - i] = Math.Max(rightMax[n - i], nums[n - 1 - i]);
            }
        }

        int[] output = new int[n - k + 1];

        for (int i = 0; i < n - k + 1; i++) {
            output[i] = Math.Max(leftMax[i + k - 1], rightMax[i]);
        }

        return output;
    }
}

class Solution {
    fun maxSlidingWindow(nums: IntArray, k: Int): IntArray {
        val n = nums.size
        val leftMax = IntArray(n)
        val rightMax = IntArray(n)

        leftMax[0] = nums[0]
        rightMax[n - 1] = nums[n - 1]

        for (i in 1 until n) {
            if (i % k == 0) {
                leftMax[i] = nums[i]
            } else {
                leftMax[i] = maxOf(leftMax[i - 1], nums[i])
            }

            if ((n - 1 - i) % k == 0) {
                rightMax[n - 1 - i] = nums[n - 1 - i]
            } else {
                rightMax[n - 1 - i] = maxOf(rightMax[n - i], nums[n - 1 - i])
            }
        }

        val output = IntArray(n - k + 1)
        for (i in 0..n - k) {
            output[i] = maxOf(leftMax[i + k - 1], rightMax[i])
        }

        return output
    }
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        let n = nums.count
        var leftMax = [Int](repeating: 0, count: n)
        var rightMax = [Int](repeating: 0, count: n)

        leftMax[0] = nums[0]
        rightMax[n - 1] = nums[n - 1]

        for i in 1..<n {
            if i % k == 0 {
                leftMax[i] = nums[i]
            } else {
                leftMax[i] = max(leftMax[i - 1], nums[i])
            }

            if (n - 1 - i) % k == 0 {
                rightMax[n - 1 - i] = nums[n - 1 - i]
            } else {
                rightMax[n - 1 - i] = max(rightMax[n - i], nums[n - 1 - i])
            }
        }

        var output = [Int](repeating: 0, count: n - k + 1)

        for i in 0..<(n - k + 1) {
            output[i] = max(leftMax[i + k - 1], rightMax[i])
        }

        return output
    }
}

impl Solution {
    pub fn max_sliding_window(nums: Vec<i32>, k: i32) -> Vec<i32> {
        let k = k as usize;
        let n = nums.len();
        let mut left_max = vec![0; n];
        let mut right_max = vec![0; n];

        left_max[0] = nums[0];
        right_max[n - 1] = nums[n - 1];

        for i in 1..n {
            left_max[i] = if i % k == 0 {
                nums[i]
            } else {
                left_max[i - 1].max(nums[i])
            };

            let j = n - 1 - i;
            right_max[j] = if j % k == 0 {
                nums[j]
            } else {
                right_max[j + 1].max(nums[j])
            };
        }

        let mut output = vec![0; n - k + 1];
        for i in 0..n - k + 1 {
            output[i] = left_max[i + k - 1].max(right_max[i]);
        }

        output
    }
}

Time & Space Complexity

Time complexity: $O(n)$
Space complexity: $O(n)$

5. Deque

Intuition

A deque helps us efficiently track the maximum inside the sliding window.
The key idea is to keep the deque storing indices of elements in decreasing order of their values.
This guarantees that:

The front of the deque always holds the index of the current window’s maximum.
Smaller elements behind a bigger one are useless (they can never become the max later),
so we remove them when pushing a new number.
If the element at the front falls out of the window, we remove it.

By maintaining this structure, each element is added and removed at most once, giving an optimal solution.

Algorithm

Use a deque to store indices of elements in decreasing order of their values.
Expand the window by moving the right pointer:
- Before inserting the new index, remove indices whose values are smaller than the new value (they cannot be future maximums).
- Add the new index to the deque.
If the left pointer passes the front index, remove it (it's outside the window).
Once the window reaches size k, the front of the deque represents the maximum — add it to the output.
Slide the window and repeat.

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        output = []
        q = deque()  # index
        l = r = 0

        while r < len(nums):
            while q and nums[q[-1]] < nums[r]:
                q.pop()
            q.append(r)

            if l > q[0]:
                q.popleft()

            if (r + 1) >= k:
                output.append(nums[q[0]])
                l += 1
            r += 1

        return output

public class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        int[] output = new int[n - k + 1];
        Deque<Integer> q = new LinkedList<>();
        int l = 0, r = 0;

        while (r < n) {
            while (!q.isEmpty() && nums[q.getLast()] < nums[r]) {
                q.removeLast();
            }
            q.addLast(r);

            if (l > q.getFirst()) {
                q.removeFirst();
            }

            if ((r + 1) >= k) {
                output[l] = nums[q.getFirst()];
                l++;
            }
            r++;
        }

        return output;
    }
}

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> output(n - k + 1);
        deque<int> q;
        int l = 0, r = 0;

        while (r < n) {
            while (!q.empty() && nums[q.back()] < nums[r]) {
                q.pop_back();
            }
            q.push_back(r);

            if (l > q.front()) {
                q.pop_front();
            }

            if ((r + 1) >= k) {
                output[l] = nums[q.front()];
                l++;
            }
            r++;
        }

        return output;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} k
     * @return {number[]}
     */
    maxSlidingWindow(nums, k) {
        const n = nums.length;
        const output = new Array(n - k + 1);
        const q = new Deque();
        let l = 0,
            r = 0;

        while (r < n) {
            while (q.size() && nums[q.back()] < nums[r]) {
                q.popBack();
            }
            q.pushBack(r);

            if (l > q.front()) {
                q.popFront();
            }

            if (r + 1 >= k) {
                output[l] = nums[q.front()];
                l++;
            }
            r++;
        }

        return output;
    }
}

public class Solution {
    public int[] MaxSlidingWindow(int[] nums, int k) {
        int n = nums.Length;
        int[] output = new int[n - k + 1];
        var q = new LinkedList<int>();
        int l = 0, r = 0;

        while (r < n) {
            while (q.Count > 0 && nums[q.Last.Value] < nums[r]) {
                q.RemoveLast();
            }
            q.AddLast(r);

            if (l > q.First.Value) {
                q.RemoveFirst();
            }

            if ((r + 1) >= k) {
                output[l] = nums[q.First.Value];
                l++;
            }
            r++;
        }

        return output;
    }
}

class Solution {
    fun maxSlidingWindow(nums: IntArray, k: Int): IntArray {
        val output = mutableListOf<Int>()
        val q = ArrayDeque<Int>()
        var l = 0
        var r = 0

        while (r < nums.size) {
            while (q.isNotEmpty() && nums[q.last()] < nums[r]) {
                q.removeLast()
            }
            q.addLast(r)

            if (l > q.first()) {
                q.removeFirst()
            }

            if ((r + 1) >= k) {
                output.add(nums[q.first()])
                l += 1
            }
            r += 1
        }

        return output.toIntArray()
    }
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        var output = [Int]()
        var deque = [Int]() // Index
        var l = 0, r = 0

        while r < nums.count {
            while !deque.isEmpty && nums[deque.last!] < nums[r] {
                deque.removeLast()
            }
            deque.append(r)

            if l > deque.first! {
                deque.removeFirst()
            }

            if (r + 1) >= k {
                output.append(nums[deque.first!])
                l += 1
            }
            r += 1
        }

        return output
    }
}

impl Solution {
    pub fn max_sliding_window(nums: Vec<i32>, k: i32) -> Vec<i32> {
        let k = k as usize;
        let n = nums.len();
        let mut output = Vec::with_capacity(n - k + 1);
        let mut q = VecDeque::new();
        let mut l = 0;

        for r in 0..n {
            while let Some(&back) = q.back() {
                if nums[back] < nums[r] {
                    q.pop_back();
                } else {
                    break;
                }
            }
            q.push_back(r);

            if l > *q.front().unwrap() {
                q.pop_front();
            }

            if r + 1 >= k {
                output.push(nums[*q.front().unwrap()]);
                l += 1;
            }
        }

        output
    }
}

Time & Space Complexity

Time complexity: $O(n)$
Space complexity: $O(n)$

Common Pitfalls

Choosing Between Values and Indices in the Deque

The deque can store either indices or values. Indices make it straightforward to detect when an element leaves the window by comparing its position with the left boundary.

A value-only deque is also correct when the original array is available. Keep duplicate values by removing only strictly smaller values from the back. When the window moves, remove one value from the front if it equals the outgoing value nums[l]. If duplicates are discarded without storing indices or counts, the deque can remove a value that still has another occurrence inside the window.

Incorrect Window Boundary Checks

Many solutions fail by using wrong conditions for when to start recording results or when to shrink the window. The first valid window exists when right >= k - 1 (or equivalently right + 1 >= k). Off-by-one errors here cause either missing the first window's maximum or including results before the window is fully formed.

Not Maintaining Decreasing Order in Deque

The deque must remain monotonic in decreasing order of value. For an index deque, both < and <= are correct when removing elements from the back. Using < retains equal values, while <= discards the older equal value because the newer occurrence has the same value and expires later. For a value-only deque without counts, use < so duplicate occurrences are retained. Forgetting to remove smaller values is the actual error because the front may no longer represent the current window's maximum.

Forgetting to Handle the Output Array Size

The number of windows is n - k + 1, not n or n - k. Allocating an output array of the wrong size leads to index out of bounds errors or missing results. This is especially problematic when k equals the array length, where there should be exactly one result.

Incorrect Segment Tree Range Queries

When using segment trees, a frequent mistake is confusing inclusive versus exclusive range boundaries. The query range [i, i + k - 1] is inclusive on both ends for a window starting at index i. Mixing up these boundaries causes queries to include elements outside the window or miss elements at the boundaries.