代码随想录算法训练营第十三天 | 题目 239. 滑动窗口最大值 题目 347.前 K 个高频元素

 239. 滑动窗口最大值

思路：借助队列，队列存放滑动窗口内有可能成为最大值的元素，在滑动窗口移向下一位时，pop掉当前滑动窗口的一个元素，并在尾部push一个新元素。

自定义队列中的pop和push函数

pop:滑动窗口要变化时，比较要移除的元素和队首元素，如果相等，那么移除，不相等的话（因为在push中已经做了工作），不用管。

push：滑动窗口要变化时，要添加元素，此时队列中存放的都是当前滑动窗口内的元素，（从队尾开始比较）比较要存放的元素和已经在队列中的元素：如果要存放的元素大于当前比较的元素，那么就剔除当前比较元素，直到要存放的元素小于当前比较的元素（剔除的元素都是在本次竞争最大值中没有竞争力的元素），然后将其加入队列。

class Solution {
private:
    class MyQueue{
    public:
        //移除元素：比较要移除的元素是否和队首元素相等，如果相等，则移除
        void pop(int val){
            if(!que.empty() && val == que.front()){
                que.pop_front();
            }
        }
        //放入元素:先移除队列里小于要放入的元素，再放入；如果要放入的元素比队列尾部的元素小，那么就加入队尾
        void push(int val){
            //因为要从尾部开始向前比较,因此用的是pop_back()移除元素
            while(!que.empty() && val > que.back()){
                que.pop_back();
            }
            que.push_back(val);
        }
        //查询当前队列里的最大值
        int front(){
            return que.front();
        }
        deque<int> que; 
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que; //创建队列
        vector<int> result; //创建存放结果的容器
        for(int i = 0; i < k; i++){
            que.push(nums[i]); //将nums中前k个元素存放进队列
        }
        result.push_back(que.front()); //将队首元素（也是该滑动窗口内的最大值）放入result中
        for(int i = k; i < nums.size(); i++){
            que.pop(nums[ i - k]);//滑动窗口移动过程，i-k是在看当前滑动窗口的第一个元素是否等于滑动窗口内的最大值
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

347.前 K 个高频元素

大顶堆：父结点的值大于等于其左右孩子结点值。

小顶堆：父结点的值小于等于其左右孩子结点值。

优先级队列（priority_queue）：以O(log n) 的效率查找一个队列中的最大值或者最小值（堆结构）。

声明形式为：priority_queue< type, container, function>；

• type：数据类型；
• container：实现优先级队列的底层容器，必须是可随机访问的容器，例如vector、deque，而不能使用list；function：元素之间的比较方式；
• function：元素之间的比较方式；

---

思路：（1）将数组元素放入unordered_map容器中，数据类型为pair<int,int>,并统计每个数组元素出现的频次，其中,key表示数组元素，value表示出现频次；

（2）自定义一个比较函数，主要比较pair<int,int>中的每个元素的第二位，即比较该元素的出现频次；

（3）用一个固定节点的priority_queue队列（小顶堆）去遍历unordered_map容器中的元素，最后没有被pop掉，即仍然在队列中的元素就频次前k高的数组元素。

为什么要用小顶堆：因为最后要留下频次高的数组元素，小顶堆根节点是所有节点中最小的值，当加入一个新值的时候，直接pop掉小顶堆根节点（比较方便）。

（4）将优先级队列中的元素按照出现频次从高到低的顺序进行输出。

class Solution {
public:
    //小顶堆
    class myCompare{
    public:
        bool operator()(const pair<int, int>& l,const pair<int, int>& r){
            return l.second > r.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        //统计数组元素出现的个数
        for(int i = 0; i < nums.size(); i++){
            map[nums[i]]++;            //key存储数组元素， value存储出现的次数
        }
        //用优先级队列排序
        //定义优先级队列
        priority_queue<pair<int, int>, vector<pair<int, int>>, myCompare>pri_que;
        //用固定大小的小顶堆扫描，留下出现频率前k高的元素
        for(unordered_map<int,int>::iterator it = map.begin(); it != map.end(); it++){
            pri_que.push(*it); //将map中的元素放入优先级队列中
            if(pri_que.size() > k){
                pri_que.pop();//如果堆的大小超出了k，那么就移除顶部元素，也就是最小的元素(要保持pri_que中元素个数小于等于k)
            }
        }
        //将元素按照出现频率由高到低输出(即接受的result从后往前排)
        vector<int> result(k);
        for(int i = k-1; i >= 0; i--){
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};