题目说明
给定一个数组 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)。