queue（一）使用优先级队列、双端队列解决滑动窗口最大值问题

滑动窗口的最大值_牛客题霸_牛客网

描述

给定一个长度为 n 的数组 num 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。

例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

窗口大于数组长度或窗口长度为0的时候，返回空。

数据范围： 1≤n≤100001≤n≤10000，0≤size≤100000≤size≤10000，数组中每个元素的值满足 ∣val∣≤10000∣val∣≤10000

要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

【解法一】暴力搜索

使用双指针卡住一段区间，然后对每一段区间进行一个最大值查找。

这里使用了一个数组来存储当前滑动窗口的内容，也可以去掉这个数组，直接进行访问即可

class Solution {
public:
    int getmaxvalue(vector<int>& num)
    {
        int res = num[0];
        for(auto& e : num)
        res = max(e, res);
        return res;
    }
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        if(size>num.size()||size==0)return res;
        auto left = num.begin();
        auto right = left + size;
        while(right!=num.end()+1)
        {
            vector<int> temp(left,right);
            res.push_back(getmaxvalue(temp));
            left++;
            right++;
        }
        return res;
    }
};

【解法二】暴力的空间优化              在原数组上进行搜索

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        if(size>num.size() || size==0) return res;
        for(int left = 0; left <= num.size()-size; left++)
        {
            int ret = 0;
            // 从每一个left后面找出一段窗口
            for(int right = left; right < left + size; right++)
            {
                ret = max(ret, num[right]);
            }
            res.push_back(ret);
        }
        return res;
    }
};

【解法三】优先级队列

优先级队列存放一个键值对，则优先级队列建堆就会按照key值来进行对应比较处理。

 emplace的用法：

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        if(size > num.size() || size == 0) return res;
        priority_queue<pair<int,int>> q;
        for(int i = 0; i < size; i++)
        {
            q.emplace(num[i],i);//存放自定义类型时需要使用emplace 会自动调用对应类型的构造函数
        }
        res.push_back(q.top().first);
        for(int i = size; i < num.size(); i++)
        {
            q.emplace(num[i], i);
            int left = i - size + 1; // 位于窗口左边界
            while(q.top().second < left)
            {
                q.pop();    // 优先级队列会根据key值进行建堆，堆顶即为最大值，
            }               // 如果这个最大值是窗口前面下标元素，使用循环直接pop掉
            res.push_back(q.top().first);
        }
        return res;
    }
};

【解法四】双端队列

创建一个队列，每次将当前元素放入队列，在队列内部查找最大值，可是队列无法进行查找，所以只能自行维护一个这样递减趋势的单调队列，让最左侧一直保持的是当前区间的最大值元素，并且要满足绝对单调递减

使用一个while循环，当队列有元素时，就要保证目前放入的元素必须按照递减顺序插入队列，那就使用当期访问元素与队尾元素进行比较，如果队尾元素小，直接把这个队尾元素pop掉，如果队尾元素大，那么满足递减趋势，将当前元素push即可。

            while(!q.empty() && num[i]>num[q.back()])
                q.pop_back();
            q.push_back(i);

 对于下标的存储：

        因为后续的滑动窗口无法判断其当前队头元素是否属于该区间，所以使用存入下标的方式解决这个问题，也可以使用方法三来存入一个键值对。

         // 在递减趋势下，最左侧一定是最大值，只需要确实当前最大值是否属于当前窗口范围
            int left = i - size + 1;//滑动窗口左边界
            while(!q.empty() && q.front() < left)   //如果队头不属于当前窗口就pop掉
                q.pop_back();
            res.push_back(num[q.front()]);

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        if(size > num.size() || size == 0) return res;
        deque<int> q;
        for(int i = 0; i < size; i++)
        {
            // 首先处理滑动前size的内部
            // 使其满足队列下标对应元素程递减趋势
            while(!q.empty() && num[i]>num[q.back()])
                q.pop_back();
            q.push_back(i);
        }
        res.push_back(num[q.front()]);// 目前队首元素即为前size个元素的最大值 

        for(int i = size; i < num.size(); i++)
        {
            while(!q.empty() && num[i]>num[q.back()])
                q.pop_back();
            q.push_back(i); // 也是同样的操作进行插入元素，保证递减趋势

            // 在递减趋势下，最左侧一定是最大值，只需要确实当前最大值是否属于当前窗口范围
            int left = i - size + 1;
            while(!q.empty() && q.front() < left)
                q.pop_back();
            res.push_back(num[q.front()]);
        }
        return res;
    }
};