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>() {@Overridepublic 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;}