【JZ-59-I】滑动窗口的最大值（队列）

题目

方法一-暴力求解

遍历数组

具体代码

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0)return new int[0];
        int[] res = new int[nums.length - k + 1];
        for(int i = 0; i <= nums.length - k; i++){
            int tmp = nums[i];
            for(int j = 0; j < k; j++){
                tmp = nums[i + j] > tmp ? nums[i + j] : tmp;
            }
            res[i] = tmp;
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：$O(nk)$，因为共有 n - k + 1 个窗口，每一个窗口内寻找最大值又需要遍历窗口内所有元素（共 k 个），故时间开销为 $O((n-k+1)k)\approx O(nk)$
• 空间复杂度：$O(1)$

方法二-队列

算法思路

问题的关键在于每一次窗口滑动后获取窗口内最大值的时间复杂度如何从 $O(k)$ 降至 $O(1)$ .
创建一个 单调队列，遍历数组时保证该队列满足下列条件，从而使得 队首元素始终为窗口内的最大元素：

1. 队列内 只包含窗口内的元素：窗口滑动时，除了移除元素 nums[i-1]还需要删除队列内的对应元素；
2. 队列内元素 非严格递减：窗口滑动新增了元素 nums[j+1]，则队列内所有小于nums[j+1]的元素都应该删除

滑动窗口部分：
左边界 $i\in [1-k,n-k]$，右边界 $j\in [0,n-1]$

• 若i > 0 && deque[0] == nums[i - 1]，队首元素出队；
• 删除队列内所有小于nums[j]的元素，保持队列内元素递减；
• 将nums[j]添加到队列中；
• 若i >= 0，即已经形成窗口，将队首元素添加到结果列表

具体代码

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0)return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int j = 0, i = 1 - k; j < nums.length; i++, j++){
            //删除队列中对应的nums[i-1]
            if(i > 0 && deque.peekFirst() == nums[i - 1]){
                deque.pollFirst();
            }
            //保持队列元素递减
            while(!deque.isEmpty() && deque.peekLast() < nums[j]){
                deque.pollLast();
            }
            deque.offerLast(nums[j]);
            //记录窗口最大值
            if(i >= 0){
                res[i] = deque.peekFirst();
            }
        }
        return res;
    }
}

减少冗余判断后的代码：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0)return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        //还未形成窗口
        for(int i = 0; i < k; i++){
            while(!deque.isEmpty() && deque.peekLast() < nums[i]){
                deque.pollLast();
            }
            deque.offerLast(nums[i]);
        }
        res[0] = deque.peekFirst();
        //形成窗口后
        for(int i = k; i < nums.length; i++){
            if(deque.peekFirst() == nums[i - k]){
                deque.pollFirst();
            }
            while(!deque.isEmpty() && deque.peekLast() < nums[i]){
                deque.pollLast();
            }
            deque.offerLast(nums[i]);
            res[i - k + 1] = deque.peekFirst();
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，遍历数组nums的时间开销为 $O(n)$；每个元素最多入队和出队一次，故单调队列的时间开销为 $O(2n)$
• 空间复杂度：$O(k)$，队列中最多同时存储 k 个元素

参考

参考