优先队列题目：滑动窗口最大值

题目

标题和出处

标题：滑动窗口最大值

出处：239. 滑动窗口最大值

难度

6 级

题目描述

要求

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

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

示例

示例 1：

输入：$\text{nums = [1,3,-1,-3,5,3,6,7], k = 3}$
输出：$\text{[3,3,5,5,6,7]}$
解释：

滑动窗口的位置	最大值
$\text{[1 3 -1] -3 5 3 6 7 }$	$\text{3}$
$\text{ 1 [3 -1 -3] 5 3 6 7 }$	$\text{3}$
$\text{ 1 3 [-1 -3 5] 3 6 7 }$	$\text{5}$
$\text{ 1 3 -1 [-3 5 3] 6 7 }$	$\text{5}$
$\text{ 1 3 -1 -3 [5 3 6] 7 }$	$\text{6}$
$\text{ 1 3 -1 -3 5 [3 6 7]}$	$\text{7}$

示例 2：

输入：$\text{nums = [1], k = 1}$
输出：$\text{[1]}$

示例 3：

输入：$\text{nums = [1,-1], k = 1}$
输出：$\text{[1,-1]}$

示例 4：

输入：$\text{nums = [9,11], k = 2}$
输出：$\text{[11]}$

示例 5：

输入：$\text{nums = [4,-2], k = 2}$
输出：$\text{[4]}$

数据范围

• $\text{1}\le \text{nums.length}\le {\text{10}}^{\text{5}}$
• ${\text{-10}}^{\text{4}}\le \text{nums[i]}\le {\text{10}}^{\text{4}}$
• $\text{1}\le \text{k}\le \text{nums.length}$

前言

假设数组 $\text{nums}$ 的长度是 $n$，则数组 $\text{nums}$ 的大小为 $k$ 的滑动窗口有 $n-k+1$ 个。最直观的做法是遍历每个大小为 $k$ 的滑动窗口寻找最大值，该做法的时间复杂度是 $O(nk)$，会超出时间限制，因此需要优化。

有两种优化方法，一是优先队列，二是单调队列。

解法一

思路和算法

对于最大值问题，可以使用基于大顶堆的优先队列，优先队列的队首元素为优先队列中的最大元素。从左到右遍历数组 $\text{nums}$ 并依次将每个元素加入优先队列，则当遍历到下标 $i$ 时，优先队列的队首元素为数组 $\text{nums}$ 从下标 $0$ 到下标 $i$ 的全部元素中的最大元素。

由于题目要求计算每个滑动窗口的最大值，因此对于每个滑动窗口，优先队列中的最大元素必须位于该滑动窗口的下标范围内，即当遍历到下标 $i$ 时，如果 $i\ge k-1$，则优先队列中的最大元素对应的下标必须在范围 $[i-k+1,i]$ 内。为了确保优先队列中的最大元素对应的下标在滑动窗口的下标范围内，优先队列需要同时存储元素和对应下标，优先队列仍满足队首元素为优先队列中的最大元素。

创建长度为 $n-k+1$ 的数组 $\text{maxArray}$ 作为结果数组，则 $\text{maxArray}[i]$ 表示数组 $\text{nums}$ 从下标 $i$ 到下标 $i+k-1$ 的滑动窗口中的最大值。

首先遍历 $\text{nums}[0]$ 到 $\text{nums}[k-1]$，将每个元素和对应下标加入优先队列，令 $\text{maxArray}[0]$ 等于这 $k$ 个元素中的最大值。然后遍历 $\text{nums}[k]$ 到 $\text{nums}[n-1]$，对于每个下标 $i$，其对应的滑动窗口的下标范围是 $[i-k+1,i]$，进行如下操作：

1. 将 $\text{nums}[i]$ 和下标 $i$ 加入优先队列；

2. 如果优先队列的队首元素对应下标小于等于 $i-k$，则将优先队列的队首元素取出，重复该过程直到优先队列的队首元素对应下标大于 $i-k$；

3. 将优先队列的队首元素赋给 $\text{maxArray}[i-k+1]$。

遍历结束之后，$\text{maxArray}$ 的每个下标处的元素即为以该下标作为开始下标的滑动窗口中的最大值。

代码

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int length = nums.length;
        int[] maxArray = new int[length - k + 1];
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
            public int compare(int[] arr1, int[] arr2) {
                return arr2[0] - arr1[0];
            }
        });
        for (int i = 0; i < k; i++) {
            pq.offer(new int[]{nums[i], i});
        }
        maxArray[0] = pq.peek()[0];
        for (int i = k; i < length; i++) {
            pq.offer(new int[]{nums[i], i});
            while (pq.peek()[1] <= i - k) {
                pq.poll();
            }
            maxArray[i - k + 1] = pq.peek()[0];
        }
        return maxArray;
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。由于优先队列中最多有 $n$ 个元素，因此每次将元素加入优先队列和从优先队列中取出的时间复杂度是 $O(\log n)$，总时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。空间复杂度主要取决于优先队列，优先队列中的元素个数不会超过 $n$。

解法二

思路和算法

解法一的时间复杂度并非最优，因为每次在优先队列中加入元素和取出元素时都需要维护优先队列的性质。可以使用单调队列降低时间复杂度，单调队列存储数组 $\text{nums}$ 的下标，满足从队首到队尾的下标对应的元素单调递减。

从左到右遍历数组 $\text{nums}$，依次将下标加入单调队列。为了维护队列的单调性，每次将下标加入单调队列之前，需要首先比较队尾下标对应的元素和当前元素，如果队列不为空且队尾下标对应的元素小于等于当前元素，则将队尾下标出队列，重复该操作直到队列为空或者队尾下标对应的元素大于当前元素，此时再将当前下标在队尾入队列。

由于第一个大小为 $k$ 的滑动窗口的下标范围是 $[0,k-1]$，因此首先将下标 $0$ 到 $k-1$ 依次加入单调队列，在此过程中维护队列的单调性。将下标 $0$ 到 $k-1$ 加入单调队列之后，队首下标对应的元素即为第一个大小为 $k$ 的滑动窗口的最大值。

当遍历到的下标 $i$ 大于 $k-1$ 时，以下标 $i$ 结尾的滑动窗口的开始下标大于 $0$，因此单调队列的队首下标可能在当前滑动窗口的下标范围之外，此时需要将队首下标出队列。具体做法是，对于 $k\le i<n$，当遍历到下标 $i$ 时，如果单调队列的队首下标是 $i-k$，则将队首下标出队列，以确保单调队列中的下标都在当前滑动窗口的下标范围内。

当单调队列中的下标都在当前滑动窗口的下标范围内时，在维护队列的单调性的前提下将当前下标 $i$ 在队尾入队列，此时队首下标对应的元素即为当前滑动窗口的最大值。

代码

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int length = nums.length;
        int[] maxArray = new int[length - k + 1];
        Deque<Integer> queue = new ArrayDeque<Integer>();
        for (int i = 0; i < k; i++) {
            int num = nums[i];
            while (!queue.isEmpty() && nums[queue.peekLast()] < num) {
                queue.pollLast();
            }
            queue.offerLast(i);
        }
        maxArray[0] = nums[queue.peekFirst()];
        for (int i = k; i < length; i++) {
            int windowIndex = i - k + 1;
            if (!queue.isEmpty() && queue.peekFirst() == i - k) {
                queue.pollFirst();
            }
            int num = nums[i];
            while (!queue.isEmpty() && nums[queue.peekLast()] < num) {
                queue.pollLast();
            }
            queue.offerLast(i);
            maxArray[windowIndex] = nums[queue.peekFirst()];
        }
        return maxArray;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要遍历数组 $\text{nums}$ 一次，由于每个下标最多入队列和出队列各一次，因此时间复杂度是 $O(n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。空间复杂度主要取决于单调队列，单调队列中的元素个数不会超过 $n$。