滑动窗口最大值

努力搬砖的小王

于 2023-02-01 15:35:19 发布

阅读量275

点赞数 1

分类专栏：算法刷题文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/weixin_43010441/article/details/128834804

版权

算法刷题专栏收录该内容

65 篇文章 0 订阅

订阅专栏

滑动窗口最大值
题目链接
给你一个整数数组 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$

解题思路

思路1

大根堆
需要定义数据类型pair<int,int>，存放元素值以及索引，根据元素值进行排序
每次新加入大根堆元素后，我们可以根据索引删除窗口之外的元素，然后返回堆顶元素值
时间复杂度 $O (n l o g n)$ ，空间复杂度 $O (n)$

思路2

单调栈，需要使用双端队列存放元素索引
对于索引i和j，如果nums[i]<=nums[j]，且i<j，那么我们可以随意删除元素i，因为它不可能是当前窗口的最大值。
所以每次加入队列元素索引j的之前，我们从队列头找到那些数值小于等于nums[j]的元素，将它们从队列中删除，并将j加入队列头。
然后我们需要从队列尾删除窗口之外的元素索引
最后返回队列尾部的索引即为我们要找的窗口中的最大值索引。
时间复杂度 $O (n)$ ，空间复杂度 $O (n)$

解题代码

代码1

class Solution {
public:
    struct cmp{
        bool operator()(pair<int,int> p1, pair<int,int> p2){
            return p1.first<p2.first;
        }
    };
    
    priority_queue<pair<int,int>,vector<pair<int,int> >, cmp>q;
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        
        for(int i=0;i<k;i++){
            q.push(make_pair(nums[i],i));
        }
        vector<int>ans;
        ans.push_back(q.top().first);
        for(int i=k;i<nums.size();i++){
            q.push(make_pair(nums[i],i));
            while(q.top().second<=i-k){
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans; 
    }
};

代码2

class Solution {
public:
    deque<int>q;
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        
        for(int i=0;i<k;i++){
            while(!q.empty()&&nums[i]>=nums[q.front()]){
                q.pop_front();
            }
            q.push_front(i);
        }
        vector<int>ans;
        ans.push_back(nums[q.back()]);
        for(int i=k;i<nums.size();i++){
             while(!q.empty()&&nums[i]>=nums[q.front()]){
                q.pop_front();
            }
            q.push_front(i);
            while(!q.empty()&&q.back()<=i-k)q.pop_back();
            ans.push_back(nums[q.back()]);
        }
        return ans; 
    }
};