代码随想录Day13：239.滑动窗口最大值，347.前 K 个高频元素

239.滑动窗口最大值

设计一个窗口，存储的是最晚会被淘汰的最大值；
规则是
1.后进窗口的值如果比先进窗口的大，那么前面的比它小的值全部从窗口删除（因为先进窗口的肯定比后进窗口的先滑走，同时后进的值已经经比前面的值大了，前面的不会比后面的存活时间更长，所以成为最大值的可能性是0）
2.后进窗口的值如果比前面的值小，那么排在前面元素值的后面，等待前面元素从窗口滑走，它就是下一个最大的
3.这样在队首的就是此时窗口的最大值

参考代码随想录的这张动图

因为涉及到从前面去掉元素和从后面去掉元素，所以采用双端队列
当最前端的元素要从窗口滑走时，从前pop，当进队元素比队中一些元素大时，从后pop

class MyQueue{
        public:
        deque<int> que;
        //如果要滑走的元素是窗口中最大的元素（也就是排在最前的元素）时，将元素从前弹出
        void pop(int val){
            if(!que.empty() && que.front() == val){
                que.pop_front();
            }
        }
        //加入元素时，判断这个元素是不是比此时窗口中的一些元素大，如果是，那么窗口中的这些小元素没有机会成为最大的元素，从后弹出，弹出后将加入的元素从后push，进行排队
        void push(int val){
            while(!que.empty()&&que.back()<val){
                que.pop_back();
            }
            que.push_back(val);
        }
        //最前端的就是最大的
        int GetMaxValInWindow(){
            return que.front();
        }
    };

整体代码先将前k个元素放进队列，取一个最大值放进结果数组
之后将要被滑出的元素pop，滑进来的元素push，再取一个最大值放进结果数组

class Solution {
private:
    class MyQueue{
        public:
        deque<int> que;
        void pop(int val){
            if(!que.empty() && que.front() == val){
                que.pop_front();
            }
        }
        void push(int val){
            while(!que.empty()&&que.back()<val){
                que.pop_back();
            }
            que.push_back(val);
        }
        int GetMaxValInWindow(){
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> res;
        for(int i=0;i<k;i++){
            que.push(nums[i]);
        }
        res.push_back(que.GetMaxValInWindow());
        for(int i=k;i<nums.size();i++){
            que.pop(nums[i-k]);
            que.push(nums[i]);
            res.push_back(que.GetMaxValInWindow());
        }
        return res;
    }
};

347.前k个高频元素

对小顶堆大顶堆不是特别理解，一知半解写上了，明天补

class Solution {
public:
    struct mycomparison{
        bool operator()(pair<int,int>&p1,pair<int,int>&p2){
            return p1.second>p2.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> mp;
        for(int i=0;i<nums.size();i++){
            mp[nums[i]]++;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison> q;
        for(auto& a:mp){
            q.push(a);
            if(q.size()>k){
                q.pop();
            }
        }
        vector<int> res;
        while(!q.empty()){
            res.push_back(q.top().first);
            q.pop();
        }
        return res;
    }
};