代码随想录day13 队列有点难

239. 滑动窗口最大值

题目

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

思考

难得做困难级的题，特别还是没做过的队列类型的题，刚开始就想着两层遍历暴力解，但发现超时了，后面看完卡哥讲解后发现用deque做非常简单，因为deque在首尾两端都可以操作：

1、先明确大体思路，先创建deque，然后遍历数组，向deque里push至nums[k-1]，接下来就是pop一个数push一个数

2、这里的pop和push有说法，要重新定义，主要目的是将deque变成一个单调递减的队列，即front大back小，要做到这一点，首先push时就要判断，即然是单调递减，那么push进来的数如果比back大，那么就pop_back（注意，这里要用while，因为可能不止pop一次），然后再push这个数；pop也有讲究，那就是要pop的元素等于队列里最大值即que.front(单调递减）才pop，因为从滑窗来看要pop的元素肯定之前遍历过，如果它小于que.front，证明根本没压入deque中，如果是大于的情况，在push的环节里就已经pop掉了，只能是等于的情况才可能pop。

3、取最大值：在遍历到k-1个数是就可以取了，是que.front

代码

class Solution {

    // 单调队列

    class myQueue {

    public:

        deque<int> que;//双端队列，头尾都可以push和pop

        void pop(int val) {

            if(!que.empty() && val == que.front()) que.pop_front();

        }

        void push(int val){

            while(!que.empty() && que.back() < val) que.pop_back();

            que.push_back(val);

        }

        int getMaxNum() {

            return que.front();

        }

    };

public:

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {

        vector<int> res;

        myQueue que;

        for(int i = 0; i < nums.size(); i++) {

            que.push(nums[i]);

            if(i>=(k-1)) {

                res.push_back(que.getMaxNum());

                que.pop(nums[i-k+1]);

            }

                

        }

        return res;

    }

};

347.前 K 个高频元素

题目

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

• 输入: nums = [1,1,1,2,2,3], k = 2
• 输出: [1,2]

思考

看到这种出现频率的题目，首先想到用map，先遍历一遍数组把每个数出现的频率记录下来，然后想着再遍历map找到频率最高的那几个，但发现要用nlogn的时间复杂度，感觉行不通，卡哥教了一招用优先级队列直接改变que的排序规律来储存map

bool operator()(const pair<int,int>& lhs, const pair<int,int>& rhs) {

        return lhs.second > rhs.second;

}

这样存入的map就是按照second即频率的大小从大到小排列的，然后当que的size大于k时就开始pop，这样最后得到的que里的元素就是数组里出现频率前k个的元素，只是que里时pair，直接取first即可

代码

class Solution {

    class cmp{

        public:

        bool operator()(const pair<int,int>& lhs, const pair<int,int>& rhs) {

            return lhs.second > rhs.second;//按照second的大小排列

        }

    };

public:

    vector<int> topKFrequent(vector<int>& nums, int k) {

        unordered_map<int,int> m;

        for(auto i : nums) {

            if(m.find(i) != m.end()) m[i]++;

            else m.insert({i,1});

        }

        priority_queue<pair<int,int>, vector<pair<int, int>>, cmp> que;//必须加vector，因为它是底座最开始比较的pair

        for(auto it : m) {

            que.push(it);

            if(que.size() > k) que.pop();

        }

        vector<int> res;

        while(!que.empty()) {

            res.push_back(que.top().first);

            que.pop();

        }

        return res;

    }

};