leetcode之hot100---滑动窗口最大值（C++）

原创已于 2024-11-28 10:01:23 修改 · 386 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

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

于 2024-11-27 19:54:46 首次发布

leetcode之hot100(C++) 专栏收录该内容

31 篇文章

订阅专栏

题目解释：

用滑动窗口的思想理解题目：

滑动窗口是一个长度为 k 的连续子数组，随着窗口的移动，每次会移出最左边的一个元素，同时在最右边添加一个新元素。
对于每次移动后的窗口，我们需要找出窗口中的最大值。

思路一：暴力解法

执行超出时间限制

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //暴力解法，枚举滑动窗口内部值，获取最大值，存入数组
        int n = nums.size();
        vector<int> result;
        
        //遍历数组
        for(int i = 0; i <= n - k; i++){
            int max_num = nums[i];
            //枚举滑动窗口内部值
            for(int j = i + 1; j <= i+k-1; j++){
                max_num = max(max_num, nums[j]);
                           
            }
            result.push_back(max_num);
        }
        return result;
        
    }
};

时间复杂度：O(n²)
空间复杂度：O(n)

思路二：优先队列法

使用一个优先队列（即大顶堆）存储滑动窗口内的元素，保证堆顶始终是当前范围内的最大值，当窗口进行滑动时，添加新元素，同时将不在窗口范围内的堆顶元素移除队列，每次滑动后，堆顶元素即为当前窗口的最大值，将其存入结果数组。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {

        int n = nums.size();
        //定义一个优先队列，里面的元素按照pair类型进行存储
        //在C++中，优先队列默认是个大顶堆
        priority_queue<pair<int, int>> q;

        //处理第一个滑动窗口
        for(int i = 0; i < k; i++){
            q.emplace(nums[i], i);
        }
        //将第一个滑动窗口中的最大值（大顶堆的堆顶）存入结果数组
        vector<int> result = {q.top().first};
        //窗口向右滑动，处理后续滑动窗口
        for(int i = k; i < n; i++){
            //将进行新滑动窗口的元素添加进优先队列中
            q.emplace(nums[i], i);
            //如果堆顶元素不在滑动窗口内，移除堆顶元素
            while(q.top().second <= i - k){
                q.pop();
            }
            //将堆顶元素存入结果数组
            result.push_back(q.top().first);
        }
        return result;
        
    }
};

pair 和 vector 的区别：

pair:

pair 是一个结构体，表示一对相关的数据，通常用于存储两个不同类型的元素。
pair 类型的对象通常包含两个成员：first 和 second，分别存储一对值。你在声明 pair 时，需要指定这两个元素的类型（可以是相同的类型，也可以是不同的类型）。
pair 不能像 vector 那样存储多个元素，而是仅仅存储一对元素。
2.vector:

vector 是一个动态数组容器，可以存储任意类型的元素，并且能够动态地调整大小。
vector 可以使用 push_back 方法向末尾添加元素。
vector 的元素可以是任何类型（包括 pair 类型），并且 vector 是一个可以存储多个元素的容器。
pair 和 vector 是否可以使用 emplace_back 或 push_back：

pair 不能使用 push_back 或 emplace_back：
由于 pair 本身是一个单一的结构体，不是一个容器，因此你不能直接向 pair 中添加元素。
pair 对象只包含两个成员 first 和 second，你只能通过赋值来修改这两个成员。
vector 可以使用 push_back 或 emplace_back：
vector 是一个动态数组，支持 push_back 方法来添加新的元素，也支持 emplace_back 来直接构造新的元素。
如果 vector 存储的是 pair 类型的元素，你可以使用 push_back 或 emplace_back 向 vector 中添加新的 pair 对象。
在使用 emplace 方法时，emplace 将构造参数传递给 pair 的构造函数：

当你使用 emplace 时，容器会将你传递给 emplace 的参数直接传递给 pair 的构造函数，而不需要先创建一个 pair 对象。
例如，使用 vector<pair<int, string>> 时，调用 emplace_back(1, "one") 相当于直接在 vector 中构造一个 pair<int, string>，而不是先构造一个临时的 pair 对象，然后再将它添加到 vector 中。

时间复杂度：O(nlogn)
空间复杂度：O(n)

思路三：双端队列法

借助一个单调队列存储滑动窗口内元素的索引，队列内索引对应nums数组中的值严格单调递减，队头元素就是滑动窗口内最大的那个数

当窗口进行滑动时，在保证队列内索引对应nums数组中的值严格单调递减添加新元素，同时将不在窗口范围内的堆顶元素移除队列，每次滑动后，堆顶元素即为当前窗口的最大值，将其存入结果数组

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        //定义一个双端队列，队内存储的元素是nums数组中的索引
        //这些元素在nums数组中是严格单调递减的
        deque<int> q;
        for(int i = 0; i < k; i++){
            //将新进入队列的元素不断与队尾元素相比较，
            //如果前者比后者大，就将队尾元素弹出队列
            while(!q.empty() && nums[i] >= nums[q.back()]){
                q.pop_back();                
            }
            //滑动窗口内元素入队
            q.push_back(i);
        }
        //定义结果数组并将第一个滑动窗口的最大值存入数组
        vector<int> result = {nums[q.front()]};
        for(int i = k; i < n; i++){
             while(!q.empty() && nums[i] >= nums[q.back()]){
                q.pop_back();                
            }
            q.push_back(i);
            //剔除滑动窗口外的值
            while(q.front() <= i - k){
                q.pop_front();
            }
            //滑动窗口最大值添加进结果数组
            result.push_back(nums[q.front()]);

        }
        return result;

        
    }
};