代码随想录算法训练营第十三天 | 单调队列解决滑动窗口、优先级队列实现大小顶堆

239 单调队列解决滑动窗口

讲解视频：单调队列正式登场！| LeetCode：239. 滑动窗口最大值_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

状态：不会做。好题。

思路

难点：如何求窗口里的最大值。

整体大框架：

遍历数组，每移动一次窗口，就执行以下三个操作：

​ ①pop：移除滑动窗口最前面的元素②push：将滑动窗口后面的元素加入滑动窗口③getMaxValue：计算滑动窗口内最大值。

但是，编程语言目前没有支持以上操作的数据结构–单调队列，所以要自己实现。

单调队列：维护队列内保持单调。关键在于如何维护元素里边的单调，即**加入元素和弹出元素时，如何维护队列**，这个规则由我们定义。tips：这里的单调队列和优先级队列不同，优先级队列是将队列内的元素排序，元素的顺序就变了。

假设滑动窗口大小为3，没必要把3个元素都放进单调队列，只需要维护【有可能成为最大值的元素】，将滑动窗口内最大值放在队列的队首，保持队列的递减特性。

push的规则：从队尾插入，一一比较，若push进来的元素比前面的都大，那前面的元素都要排除，直到前面的元素比push进来的元素大停止，停在大元素的后面。这里有两个疑难点：①为什么前面的元素都要排除？因为该单调队列要维护的是“将滑动窗口内的最大值放在队首”。②push进来的元素，为什么遇到比自己大的就停止，而不是不入队？因为最大元素(即队首元素)弹出后，需要将当前窗口内第二大的元素变成最大元素，也就是说，push进来的元素有可能是成为最大值的元素，而前面那些比push进来的元素小的元素自然不可能是当前窗口最大值的候选(因为比push进来的元素小)，所以要排除。

pop的规则：若滑动窗口移除的元素是单调队列的队首(即最大元素)，就将该元素从单调队列弹出。

getMaxValue的规则：获取单调队列的队首元素值即可。

代码

用双向队列deque来实现

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值(即滑动窗口的最大值)，如果相等则弹出。
        // 同时pop之前判断队列当前是否为空。
        void pop(int value) {	// value为滑动窗口要遗弃的元素
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        // 如果push的数值大于入口(队尾)元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);
        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front() {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};

347 优先级队列实现小顶堆

讲解视频：优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

状态：不会做。好题。

思路

1. 要统计元素出现频率：用map统计；
2. 对频率排序：用优先级队列（小顶堆）。
3. 找出前K个高频元素

什么是优先级队列priority_queue？

其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

而且优先级队列内部元素是自动依照元素的权值排列，这个权值可以自己定义，比如队列元素为map，就可以自定义是根据key比较，还是根据value比较，可以自定义是降序或者升序。

那么它是如何有序排列的呢？

缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。

什么是堆呢？

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆（队首元素最小，队尾元素最大），从大到小排就是大顶堆（队首元素最大，队尾元素最小）。

为什么不用快排呢

使用快排要将map转换为vector的结构，然后对整个数组进行排序，时间复杂度为O(nlogn)； 而这种场景下，我们其实只需要维护k个有序的序列就可以了，当输入第k+1个元素时就从这k+1个元素中剔除值最小的，堆中始终保持值最大的k个元素。时间复杂度为O(nlogk)，所以使用优先级队列是最优的。

使用大顶堆还是小顶堆？

定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。

所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

寻找前k个最大元素流程如图所示：

（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）

代码

注：优先级队列priority_queue有函数top()，表示堆顶元素；函数pop()表示弹出堆顶。

class Solution {
public:
    //优先级队列的元素为map，这里为小顶堆的比较方法：比较map的value
    class mycomparison{
        public:
        bool operator()(const pair<int,int>& lhs, const pair<int, int>& rhs){
            //!注意这里：优先级队列比较方式的定义与快排的cmp函数相反
            return lhs.second > rhs.second;
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        /*统计元素出现频率*/
        unordered_map<int, int> maps;
        for(int i = 0; i < nums.size(); ++i){
            maps[nums[i]]++;
        }

        /*对频率排序*/
        //这里的定义pair<int, int>表示map，而vector则是堆在priority_queue的表现形式；mycomparison则是比较方法，确定为小顶堆
        priority_queue<pair<int, int>, vector<pair<int,int>>, mycomparison> pri_que;
        //遍历map，逐一插入priority_queue，priority_map会自动根据map的value来排序
        for(unordered_map<int, int>::iterator it = maps.begin(); it != maps.end(); it++){
            pri_que.push(*it);
            //如果堆的大小大于了K，则弹出队列中的最小元素，保证堆的大小一直为k
            if(pri_que.size() > k){
                pri_que.pop();
            }
        }

        /*找出前K个高频元素*/
        vector<int> res(k);
        for(int i = k - 1; i >= 0; --i){
            res[i] = pri_que.top().first; //存入的是map的key，即元素值，而不是频率
            pri_que.pop();  //弹出堆顶
        }
        return res;
    }
};