刷题心得2——滑动窗口最大值(单调队列经典题)

题目链接：239. 滑动窗口最大值 - 力扣（LeetCode）

题面：

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

思路：一开始的思路是使用hash map来写，因为map真的非常方便，这里来复习一下map的用法吧。

map是红黑树结构的

map的插入、查找、删除都是O(logN)时间复杂度的。unordered_map的插入和查询时间复杂度是O(1)的。

map<int,int> mp;

插入:mp[10]=1;

查找:cout<<mp[10];

因为map是有序的，所以可以很快的找到最大和最小值。

遍历代码：

\\从前往后遍历(从小到大)
map<int, int>::iterator iter; \\定义迭代器
for (iter = mp.begin(); iter != mp.end(); ++iter) 
{
    cout << iter->first << " => " << iter->second << '\n';
}
\\从后往前遍历(从大到小)
map<int, int>::reverse_iterator iter;
for (iter = mp.rbegin(); iter != mp.rend(); ++iter) 
{
    cout << iter->first << " => " << iter->second << '\n';
}

所以如果要找最小map对

map<int, int>::iterator iter;
iter =mp.begin(); 
cout<< iter->first << " => " << iter->second << '\n';

如果找最大的map对

map<int, int>::reverse_iterator iter;
iter =mp.rbegin(); 
cout<< iter->first << " => " << iter->second << '\n';

删除:

mp[5]=0;
mp.earse(5);

解法1：

下边是我的解题代码（只要保证窗口中的值都在map中记录，每向右移动一步就找到当前的最大值即可）：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        map<int,int> mp;
        vector<int> ans;
        int len=nums.size();
        int num=0;
        for(int i=0;i<len;i++){
            mp[nums[i]]++;
            num++;
            if(num>=k){
                if(num>k){
                    int nn = mp[nums[i-k]];
                    if(nn==1) mp.erase(nums[i-k]);
                    else  mp[nums[i-k]]--;
                }
                map<int, int>::reverse_iterator iter;
                iter =mp.rbegin(); 
                ans.push_back(iter->first);
            }
        }
        return ans;
    }
};

过了，但是时间复杂度和空间复杂度都很高。

看一眼题解，发现使用优先队列进行解题的（时间复杂度依然很高）。

回顾一下优先队列(priority_queue就是一个有序的队列)。

priority_queue<int> q;
插入：q.push(5) 
查看顶端元素:q.top()
删除顶端元素:q.pop()

解法2：

在这里的定义是priority_queue<pair<int,int>> q;

存入两个值，分别是 值的大小和位置。

每次找结果的时候就判断当前的顶端的元素的位置是不是在当前区间内（如果不在就while删除）。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //使用优先队列 priority_queue
        //每次存值和位置,然后输出的时候判断当前的值是不是在当前的窗口中
        priority_queue<pair<int,int>> q;//先存大小再存位置
        int len=nums.size();
        for(int i=0;i<k;i++){
            q.push({nums[i],i});
        }
        vector<int> ans;
        ans.push_back(q.top().first);
        for(int i=k;i<len;i++){
            q.push({nums[i],i});
            while(q.top().second<=i-k){
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

解法3：

这个题的正确做法应该是单调队列。（这题是单调队列的经典题）

这里我使用的数组que来表示的单调队列(队列和栈使用数组来模拟的话会非常非常方便)

int que[200005];
int l=0,r=-1;//l==r时表示有一个值
//这样就方便输出队列的所有值
for(int j=l;j<=r;j++)
    cout<<que[j]<<' ';
cout<<endl;

我们需要做的是需要维护一个单调递减的队列。

单调队列是判断当前的输入的值跟之前的队尾比，如果队尾的元素比当前值小，那它完全没用了（对于后面来说，肯定是当前值又在右边，又大，肯定当前值有用），队尾元素删除。

然后再判断一下队首元素是否在当前区间中（存储的是位置的作用就在这）

以下是单调队列的代码：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int que[200005];//存储的是一个从大到小的单调队列,注意，这里存储的是nums的下标idx
        int l=0,r=-1;//如果l==r的话就代表有一个r的位置是
        vector<int> ans;
        
        //判断的是当前的值，当前的值如果比前一个值大，那么前边那个值就没用了
        for(int i=0;i<k;i++){
            while(r>=l&&nums[que[r]]<=nums[i]){
                r--;
            }
            que[++r]=i;
        }
        ans.push_back(nums[que[l]]);
        for(int i=k;i<nums.size();i++){
            while(r>=l&&nums[que[r]]<=nums[i]){
                r--;
            }
            que[++r]=i;
            while(que[l]<=i-k){//判断当前位置有没有在
                l++;
            }
            ans.push_back(nums[que[l]]);
        }

        return ans;
    }
};

以下我输出了单调队列的所有过程：

输入

nums =[1,3,-1,-3,5,3,6,7]
k =3

标准输出（输出的是下标）

1 2  
1 2 3  
4
4 5  
6  
7