【10.3】队列-解滑动窗口最大值

原创已于 2025-01-23 11:01:56 修改 · 1k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #c++

于 2025-01-23 10:59:51 首次发布

C/C++算法专栏收录该内容

110 篇文章

订阅专栏

一、题目

给你一个整数数组 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]

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

二、解题思路

对于每一个滑动窗口，我们需要遍历其中的所有 k 个元素来找到最大值，这需要 O(k) 的时间。对于一个长度为 n 的数组 nums 来说，总共有 n−k+1 个滑动窗口，因此整个算法的时间复杂度为 O((n−k+1)k)=O(nk)。这样的时间复杂度在数据规模较大时会导致性能问题，无法通过时间限制，因此我们需要寻找更高效的优化方法。

注意到相邻的两个滑动窗口之间，有 k−1 个元素是重叠的，只有 1 个元素发生了变化。基于这一特点，我们可以利用这些重叠的部分来减少重复计算，从而优化算法的时间复杂度。

2.1 使用优先队列

为了解决滑动窗口中的最大值问题，我们可以借助一种非常适合处理极值问题的数据结构——优先队列（堆）。具体来说，大根堆可以帮助我们动态维护一组元素中的最大值。

在实现过程中，我们首先将数组 `nums` 的前 `k` 个元素插入到优先队列中。每当窗口向右滑动时，我们将一个新元素加入优先队列，此时堆顶元素即为当前堆中的最大值。然而，这个最大值可能并不属于当前滑动窗口，因为它可能位于窗口左侧边界之外。这意味着随着窗口的继续滑动，这个值将永远不可能再出现在窗口中，因此我们可以将其从优先队列中永久移除。

为了确保堆顶元素始终位于当前滑动窗口内，我们需要不断地检查并移除堆顶元素，直到找到一个确实属于当前窗口的最大值。为了更方便地判断堆顶元素是否在窗口内，我们可以在优先队列中存储元素的数值及其在数组中的下标，即二元组 `(num, index)`，其中 `num` 表示元素的值，`index` 表示元素在数组中的位置。通过这种方式，我们可以快速确定堆顶元素是否在滑动窗口范围内。

#include <iostream>
#include <vector>
#include <queue> // 包含优先队列的头文件
using namespace std;

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size(); // 数组长度
        priority_queue<pair<int, int>> maxHeap; // 大根堆，存储（元素值，下标）

        // 初始化第一个窗口
        for (int i = 0; i < k; ++i) {
            maxHeap.emplace(nums[i], i); // 将元素值及其下标加入堆
        }

        vector<int> ans = {maxHeap.top().first}; // 第一个窗口的最大值

        // 滑动窗口
        for (int i = k; i < n; ++i) {
            maxHeap.emplace(nums[i], i); // 将新元素加入堆

            // 移除不在当前窗口内的堆顶元素
            while (maxHeap.top().second <= i - k) {
                maxHeap.pop();
            }

            ans.push_back(maxHeap.top().first); // 当前窗口的最大值
        }

        return ans; // 返回结果
    }
};

int main() {
    Solution solution;

    // 测试用例
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;

    // 获取滑动窗口的最大值
    vector<int> result = solution.maxSlidingWindow(nums, k);

    // 输出结果
    cout << "滑动窗口的最大值: ";
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

时间复杂度：

O(n log n)，其中 n 是数组 nums 的长度。
在最坏的情况下，如果数组 nums 中的元素是单调递增的，那么优先队列会包含所有元素，且没有元素会被移除。由于每次将一个元素插入优先队列的时间复杂度为 O(log n)，因此总的时间复杂度为 O(n log n)。

空间复杂度：

O(n)，即优先队列所需的空间。
这里的空间复杂度分析仅考虑额外的空间使用，不包括返回答案所需的 O(n) 空间。在最坏情况下，优先队列可能会存储所有 n 个元素，因此空间复杂度为 O(n)。

2.2 单调队列

为了求解滑动窗口中的最大值，我们可以考虑以下情况：假设当前窗口中有两个下标 `i` 和 `j`，其中 `i` 位于 `j` 的左侧（即 `i < j`），并且 `i` 对应的元素值不大于 `j` 对应的元素值（即 `nums[i] ≤ nums[j]`）。此时会发生什么呢？

当滑动窗口向右移动时，只要 `i` 仍然位于窗口内，那么 `j` 也一定位于窗口内（因为 `i` 在 `j` 的左侧）。这意味着，由于 `nums[j]` 的存在，`nums[i]` 永远不可能成为当前窗口的最大值。因此，我们可以将 `nums[i]` 永久地从考虑范围中移除。

基于这一观察，我们可以使用一个队列来存储所有可能成为窗口最大值的元素的下标。在这个队列中，下标按照从小到大的顺序排列，并且它们对应的元素值是严格单调递减的。如果队列中存在两个相邻的下标，它们对应的元素值相等或递增，那么根据前面的分析，前一个下标对应的元素可以被移除，这与队列的性质矛盾。

当滑动窗口向右移动时，我们需要将一个新元素加入队列。为了维护队列的单调性，我们会不断地将新元素与队尾元素进行比较。如果新元素大于或等于队尾元素，那么队尾元素可以被永久移除，我们将其从队列中弹出。这一过程会持续进行，直到队列为空或新元素小于队尾元素。

由于队列中的下标对应的元素值是严格单调递减的，此时队首元素对应的值就是当前窗口的最大值。然而，与方法一类似，这个最大值可能位于窗口左侧边界之外。随着窗口的继续移动，这个值将永远不可能再出现在窗口中。因此，我们需要不断地从队首弹出元素，直到队首元素位于当前窗口内。

为了能够同时从队首和队尾弹出元素，我们需要使用双端队列（deque）。这种满足单调性的双端队列通常被称为「单调队列」。通过这种方式，我们可以高效地维护滑动窗口的最大值。

#include <iostream>
#include <vector>
#include <deque> // 包含双端队列的头文件
using namespace std;

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size(); // 数组长度
        deque<int> windowIndices; // 双端队列，存储可能成为窗口最大值的元素的下标

        // 初始化第一个窗口
        for (int i = 0; i < k; ++i) {
            // 维护队列单调性：移除比当前元素小的队尾元素
            while (!windowIndices.empty() && nums[i] >= nums[windowIndices.back()]) {
                windowIndices.pop_back();
            }
            windowIndices.push_back(i); // 将当前元素的下标加入队列
        }

        vector<int> ans = {nums[windowIndices.front()]}; // 第一个窗口的最大值

        // 滑动窗口
        for (int i = k; i < n; ++i) {
            // 维护队列单调性：移除比当前元素小的队尾元素
            while (!windowIndices.empty() && nums[i] >= nums[windowIndices.back()]) {
                windowIndices.pop_back();
            }
            windowIndices.push_back(i); // 将当前元素的下标加入队列

            // 移除不在当前窗口内的队首元素
            while (windowIndices.front() <= i - k) {
                windowIndices.pop_front();
            }

            ans.push_back(nums[windowIndices.front()]); // 当前窗口的最大值
        }

        return ans; // 返回结果
    }
};

int main() {
    Solution solution;

    // 测试用例
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;

    // 获取滑动窗口的最大值
    vector<int> result = solution.maxSlidingWindow(nums, k);

    // 输出结果
    cout << "滑动窗口的最大值: ";
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

时间复杂度：