栈与队列：滑动窗口最大值 前K个高频元素

滑动窗口最大值

• 题目：Leetcode239

• 思路：

  • 为什么不能使用大顶堆：这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了，所以不能用大顶堆。

  • 需要自定义一个可以维护元素单调递减的队列，叫做单调队列，即单调递减或单调递增的队列。队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

  • 设计单调队列的时候，pop，和push操作要保持如下规则：

    • pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
    • push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

  • 保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

• 时间复杂度: O(n)
• 空间复杂度: O(k) 

class Solution {
public:
    //自定义单调队列以及规则(单调递减)
    class myQueue {
    public:
        deque<int> que;
        //当预备弹出的值与队头元素相等，也就是与最大值相等时，弹出该值
        void pop(int val) {
            if(!que.empty() && val == que.front()) {
                que.pop_front();
            }
        }
        //将准备进入滑动窗口的值val，与队列入口(队尾)元素相比较，若val更大，则弹出队尾元素，再依次向前比较，直到不再大于队尾元素时，将val入队
        //保证了单调队列中元素为递减趋势
        void push(int val) {
            while(!que.empty() && val > que.back()) {
                que.pop_back();
            }
            que.push_back(val);
        }
        //获取滑动窗口中最大值，只需获取单调队列中的队头元素
        int front() {
            return que.front();
        }
    };

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        myQueue que;
        vector<int> res;//存放结果
        //将前k个元素先入单调队列
        for(int i = 0; i < k; i++) {
            que.push(nums[i]);
        }
        res.push_back(que.front());//存放前k个元素中最大的元素
        //移动滑动窗口，逐一找到结果
        for(int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]);//弹出滑动窗口最前面的元素
            que.push(nums[i]);//移动滑动窗口，加入后面一个元素
            res.push_back(que.front());//存储当前滑动窗口中的最大值
        }
        return res;
    }
};

前K个高频元素

• 题目：Leetcode347
• 思路：
  • 本题需要完成统计元素出现频率、对频率排序、找出前K个高频元素。统计频率可以使用map，对频率进行排序，可以使用一种容器适配器也就是优先级队列。
  • 什么是优先级队列？
    • 一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列，优先级队列内部元素是自动依照元素的权值排列。
  • 为什么不用快排？
    • 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。
  • 为什么使用小顶堆？
    • 一个大小为k的大顶堆，在每次移动更新大顶堆的时候，会把最大的元素弹出去，无法保留频率最高的k个元素。
    • 所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。
• 时间复杂度: O(nlogk)
• 空间复杂度: O(n)

class Solution {
public:
    //小顶堆
    class myComparison {
    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> umap;
        //统计元素出现的频率
        for(int i = 0 ; i < nums.size(); i++) {
            umap[nums[i]]++;
        }
        //定义优先级队列，使用小顶堆，只维护k个元素
        priority_queue<pair<int, int>, vector<pair<int, int>>, myComparison> pque;
        //用固定大小为k的小顶堆，扫面所有频率的数值
        for(unordered_map<int, int>::iterator it = umap.begin(); it != umap.end(); it++) {
            pque.push(*it);
            if(pque.size() > k) pque.pop();//若堆大小超过k，则弹出堆顶元素，也就是最小元素，保证堆大小始终为k
        }

        //存储结果
        vector<int> res;
        for(int i = 0; i < k; i++) {
            res.push_back(pque.top().first);
            pque.pop();
        }

        return res;
    }
};

参考链接

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