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

一、LeetCode 239. 滑动窗口最大值

题目链接/文章讲解/视频讲解： https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html

状态：已解决

1.思路 

        第一眼暴力，第二眼有点单调队列的感觉，想着几个数连在一起那么保留最大值就可以了，但想来想去又pass掉这个想法了，后面看了讲解才发现这种想法出发点是对的，但是只对了一半。

问题的核心：

（1）pop最左端的元素

（2）push下一个右端元素

（3）求滑动窗口最大值

        因为要按顺序pop元素，故不能用大顶堆（优先级队列）来存放滑动窗口内的值，否则每次只能弹出最大值。

        其实这道题最难的地方就是求滑动窗口最大值，不用暴力排序的话，怎么做呢？其实有一个很巧妙的方法：例如已知一个序列[1,2,3,-1,5,4]，k=3，前三个数字为[1,2,3]，那么我们取3，然后pop掉1，接着进来-1，照例取3，然后pop掉2，那么，为什么我们一开始不直接存3呢？其实是可以的，因为1,2,3已经在滑动窗口内了，而最大值出现在靠后面，那么比它小的前面的数字就不用存，因为只要有3在窗口内，最大值要么取3，要么从3后面的数字开始取。因此，窗口的最前端（出口端）永远是队列最大值（前面的比它小的都丢掉了）。解决了窗口出端的问题，那么窗口的入口端（右端）又该怎么处理呢？其实也很简单，因为队列出口端维护的始终是最大值，那么后面新进来的数，如果比前面的数都大，按照刚刚说的原理，应该把前面的数都丢掉，那如果比前面的数都小呢？那应该保留下来，因为现在最小不代表把前面的元素pop后它还是最小。两种不同大小的元素不同处理方式的根本原因是：比前面某些元素大的新进元素，假如这个区间选最大值，那么一定不会选它前面比更小的元素；而比前面元素都小的新进元素，假如这个区间不是最大值，但很有可能未来在后面的区间可能成为最大值。本质是因为我们可以判断已经在窗口中的元素的最大值，而不能预测未来还没有出现在窗口中的元素的最大值。

        这样处理下来，整个队列都是单调递减的，因而叫单调队列，但它和优先队列不一样，因为优先队列是排序，而单调队列是维护。

        即构造这样的队列：

（1）pop(value)：如果窗口移除的元素value等于单调队列的出口元素（最大值），那么队列弹出元素，否则不用任何操作。

（2）push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止。

2.代码实现 

class Solution {
private:
    class MyQue{
    public:
        deque<int> q;
        void pop(int value){
            if(!q.empty() && q.front() == value){
                q.pop_front();
            }
        }
        void push(int value){
            while(!q.empty() && value>q.back()){
                q.pop_back();
            }
            q.push_back(value);
        }

        int front(){
            return q.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQue q;
        vector<int> result;
        for(int i=0;i<k;i++){
            q.push(nums[i]);
        }
        result.push_back(q.front());

        for(int i=1;i<nums.size()-k+1;i++){
            q.pop(nums[i-1]);
            q.push(nums[i+k-1]);
            result.push_back(q.front());
        }
        return result;
    }
};

时间复杂度：O(n)

空间复杂度：O(k)

二、LeetCode 347.前 K 个高频元素 

题目链接/文章讲解/视频讲解： https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html

状态：已解决

1.思路 

        第一反应是没有反应，跑去看了讲解，典型的优先队列。

这道题的核心问题是：

（1）统计元素出现频率

（2）对频率排序

（3）找出前k个高频元素

        对于（1），根据前面哈希表相关练习的时候我们很容易想到用map这种数据结构（因为既要记录元素，又要记录频率）。

        对于（2），这里介绍的是优先队列。优先队列其实是一种堆结构，分为大顶堆（堆头是最大元素）和小顶堆两种（堆头是最小元素）。说是队列，其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列，而且优先级队列内部元素是自动依照元素的权值排列，具体排序原理这里不过多介绍。此题我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。反之统计前最小，用大顶堆。

        寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）

        对于（3），只需逆序输出队列即可。

2.代码实现 

class Solution {
public:
    class mycomparison{
        public:
            bool operator()(const pair<int,int>& lhs,const pair<int,int>& rhs){
                return lhs.second > rhs.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]]++;
        }//统计频率

        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison> pri_queue;
        //小根堆定义方式。

        for(auto iter:map){
            pri_queue.push(iter);
            if(pri_queue.size() > k){
                pri_queue.pop();
            }
        }//依次扫描排序

        vector<int> result(k);//因为逆序输出，故需要先预留空间。
        for(int i=k-1;i>=0;i--){
            result[i] = pri_queue.top().first;
            pri_queue.pop();
        }
        return result;
    }
};

时间复杂度：O(nlogk) //小根堆是快排

空间复杂度： O(n) //map是n