Leetcode-239-滑动窗口的最大值

题目说明

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

示例1:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:

滑动窗口的位置 最大值

---

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

示例 2：
输入：nums = [1], k = 1
输出：[1]

思路分析

这是一个典型的滑动窗口的问题。由于滑动窗口的大小k被限定在[1, nums.length]，所以我们可以直接推出窗口的个数为nums.length - k + 1。

解题方法

方法一：暴力法

最简单直接的方法，就是遍历每个滑动窗口，找到每个窗口的最大值。

public class SlidingWindowMaximum {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] result = new int[nums.length - k + 1];
        // 遍历数组
        for(int i = 0; i <= nums.length - k; i++){
            int max = nums[i];
            for(int j = i; j < i + k; j++){
                if( nums[j] > max ){
                    max = nums[j];
                }
            }
            result[i] = max;
        }
        return result;
    }
}

复杂度分析

时间复杂度： O(Nk)，双重循环，外层遍历数组循环N次，内层遍历窗口循环k次，所以整体就是O(N) * O(k) = O(Nk)，表现较差。在leetcode上提交，会发现超出了题目要求的运行时间限制。

空间复杂度：O(N-k)，输出数组用到了N-k+1的空间。

方法二：使用堆

如何优化时间复杂度呢？可以使用堆。
构建一个大顶堆（Max Heap），那么堆顶元素 heap[0] 永远是最大的。每次移动窗口的时候，我们只要维护这个堆、在里面插入删除元素，然后返回堆顶元素heap[0]就可以了。
在代码中，我们可以用一个优先队列（Priority Queue）来实现大顶堆。

public int[] maxSlidingWindow(int[] nums, int k) {
    int[] result = new int[nums.length - k + 1];
    // 用优先队列定义一个大顶堆
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1; 
        }
    });
    for (int i = 0; i < k; i++) {
        maxHeap.add(nums[i]);
    }
    result[0] = maxHeap.peek();
    // 遍历数组
    for(int i = 1; i <= nums.length - k; i++){
        maxHeap.remove(nums[i - 1]); 
        maxHeap.add(nums[i + k - 1]); 
        result[i] = maxHeap.peek();
    }
    return result;
}

复杂度分析

时间复杂度： O(Nlog(k))，在大小为 k 的堆中插入一个元素只需要消耗 log(k) 时间，因此这样改进后，算法的时间复杂度为O(Nlog(k))。但提交依然会超出时间限制。

空间复杂度：O(N)，输出数组用到了O(N-k+1)的空间，大顶堆用了O(k)。

方法三：使用双向队列

使用堆看起来不错，但离题目要求还有差距。能否得到O(N) 的算法呢？

我们发现，窗口在滑动过程中，其实数据发生的变化很小：只有第一个元素被删除、后面又新增一个元素，中间的大量元素是不变的。也就是说，前后两个窗口中，有大量数据是 重叠 的。

[1, 3, -1,] -3, 5, 3, 6, 7
1, [3, -1, -3,] 5, 3, 6, 7
1, 3, [-1, -3, 5,] 3, 6, 7
1, 3, -1, [-3, 5,3,] 6, 7
1, 3, -1, -3,[ 5,3, 6, ]7
1, 3, -1, -3, 5,[3, 6, 7]

自然想到，其实可以使用一个 队列 来保存窗口数据：窗口每次滑动，我们就让后面的一个元素（-3）进队，并且让第一个元素（1）出队。进出队列的操作，只要耗费常数时间。

这种场景，可以使用 双向队列（也叫双端队列Dequeue），该数据结构可以从两端以常数时间压入/弹出元素。
在构建双向队列的时候，可以采用删除队尾更小元素的策略，所以，得到的其实就是一个 从大到小排序 的队列。
这样存储的元素，可以认为是遵循“更新更大”原则的。

    public int[] maxSlidingWindow(int[] nums, int k) {
            if (nums == null || k < 1 || nums.length < k) {
                return null;
            }
            // qmax 窗口最大值的更新结构
            // 注意双端队列里存放的是  放下标
            LinkedList<Integer> qmax = new LinkedList<Integer>();
            int[] res = new int[nums.length - k + 1];
            int index = 0;
            for (int R = 0; R < nums.length; R++) {
                //如果队列中有值，那么就判断进来的数是否大于之前进来的数，如果大于就把之前的数弹出
                while (!qmax.isEmpty() && nums[qmax.peekLast()] <= nums[R]) {
                    qmax.pollLast();
                }
                
                qmax.addLast(R);
                //判断头部对应下标是否过期，是否该弹出了
                if (qmax.peekFirst() == R - k) {
                    qmax.pollFirst();
                }
                //依次取经过每个滑动窗口的最大值,即如果还没有具备窗口规模不收集
                if (R >= k - 1) {
                    res[index++] = nums[qmax.peekFirst()];
                }
            }
            return res;
    }

复杂度分析
时间复杂度：O(N)，每个元素被处理两次：其索引被添加到双向队列中，以及被双向队列删除。

空间复杂度： O(N)，输出数组使用了 O(N−k+1) 空间，双向队列使用了O(k)。