经典题目：滑动窗口的最大值+前 K 个高频元素

1、滑动窗口的最大值：
经典算法：深度优先队列（deque）

class myqueue{
    public:
        deque<int> que;
        void pop(int value){
        if(!que.empty() && value == que.front()){      //由于队列只维护单调递减的序列，因此在第一个元素之前可能还有元素不过被弹出了，导致目前元素数目小于窗口大小，因此只有当value == que.front()时才弹出，否则不操作；
            que.pop_front();
            
        }
    }
    void push(int value){
        while(!que.empty()&&value>que.back()){
            que.pop_back();//如果要压入的元素比队列末尾的大，说明此时不是单调减的，从末尾弹出直到队列为单调递减，这样可以保证front的元素为最大。
            
        }
        que.push_back(value);
    }
    int front(){
        return que.front();
    }
};


class Solution {
public:
   
    
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
         myqueue que;
        int max = INT_MIN;
        vector<int> result;
        if(size==0 || size>num.size()) {return result;}
      
        for(int i = 0;i<size;i++){
            que.push(num[i]);
        }
       
        result.push_back(que.front());
        for(int i = size; i<num.size();i++){
            que.pop(num[i-size]);//先弹出再压
            que.push(num[i]);
            result.push_back(que.front());
        }
       return result;
    }
};

2、前 K 个高频元素：

//升序队列
priority_queue <int,vector<int>,greater<int> > q;
//降序队列
priority_queue <int,vector<int>,less<int> >q;

找到前k次个高频元素：
1:要统计元素出现频率
2:对频率排序
3:找出前K个高频元素
思路：利用优先级队列，大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），为什么不用快排呢， 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素，如果队列大小大于k了则直接弹出；

注意：优先级队列的三个参数：其中Container必须是vector构造的
定义：priority_queue<Type, Container, Functional>
左大于右就会建立小顶堆，使用基本数据类型时，只需要传入数据类型，默认是大顶堆

class mycompare{
    public:
        bool operator()(const pair<int, int> &left, const pair<int, int> &right){
          return left.second > right.second; }

};
class Solution {
public:
    
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for(int i = 0;i<nums.size();i++){
            map[nums[i]]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycompare> pri_que;
        for(unordered_map<int, int>::iterator it=map.begin();it != map.end();it++){
            pri_que.push(*it);
            if(pri_que.size()>k) pri_que.pop();
        }
    
    vector<int> result(k);
    for(int i = k-1;i>=0;i--){
        result[i] = pri_que.top().first;
         pri_que.pop();
    }
return result;

    }
};

3.利用优先级队列排序，输出前k个小元素；
构建大顶堆，每次弹出最大的元素，剩下的都是小的；

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        if(k==0||k>input.size()) return {};
        
        priority_queue<int, vector<int>> pri_que;
        for(const int val:input){
            if(pri_que.size()<k) pri_que.push(val);
            else{
                if(val<pri_que.top()) {
                    pri_que.pop();
                    pri_que.push(val);
                }
            }
        }
        vector<int> res(k);
        for(int i=k-1;i>=0;i--){
            res[i] = pri_que.top();
            pri_que.pop();
        }
        return res;
    }
};