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

239.滑动窗口最大值

题目链接/文章讲解/视频讲解：代码随想录

解题思路

 首先我们想到的肯定是暴力解法，但这样会超时，其次可能想到的是大顶堆，但这样我们每次弹出的只是最大值，加入和移除别的元素并不好操作，因此我们只需要利用单调队列来完成这道题即可，我们的队列只需要三个操作就可以保证单调，我们并不需要维护所有的元素，我们只需要维护可能成为最大值的元素，因此我们push进来元素时，要将单调队列入口处所有比它小的都弹出，而pop函数只需要当我们弹出的是最大值时，才操作，否则不操作，最后就是获取最大值函数，也就是我们已经维护好的最大的元素，队列的front

 

class Solution {
private:
    class Myque{
        public:
         deque<int> que;  //双向队列，栈和队列底层都是用这个实现的
        void pop(int val)
        {
            //每次移除一个元素，只有当这个元素移除的最大值时，才移除
            if(!que.empty()&&val==que.front())
            {
                que.pop_front();
            }
        }
        void push(int val)
        {
            //每次push元素进来时，和入口处的元素比较，确保他前面没有比它小的元素，这是形成单调队列的重要因素
            while(!que.empty()&&val>que.back())
            {
                que.pop_back();
            }
            que.push_back(val);
        }
        int front()
        {
            return que.front();   //队列的出口第一个元素就是最大值
        }
    };
    
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
       Myque que;
       vector<int> result;
       for(int i=0;i<k;i++)   //窗口初始化
       {
           que.push(nums[i]);
       }
       result.push_back(que.front());   //将第一个窗口最大值放入
        for(int i=k;i<nums.size();i++)
        {
            que.pop(nums[i-k]);    //每次弹出窗口最后一个元素，如果是最大值就弹出
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

时间复杂度；O（n）

空间复杂度：O（k）

总结

这题利用的就是一个单调队列的操作，我们弄懂单调队列的逻辑即可，只需要去维护最大值就可以了，对于类似于滑动窗口的最大值（小）值这类问题，可以想到单调队列这种方法

347.前 K 个高频元素

题目链接/文章讲解/视频讲解： 代码随想录

解题思路

 这题我们需要解决三个问题，一个是统计元素出现的频率，利用hashmap即可，第二个对频率排序，我们可以使用优先队列（本质是堆实现的），最后是找出前k个高频，那我们应该用的是小顶堆（父节点必定小于子节点），这样我们维护的是最小的元素，每次弹出的栈顶的也就是最小的元素，保留了最大的，也就是我们需要的

 

class Solution {
    //小顶堆比较函数，重载仿函数
    class Mycomparator{
        public:
        bool operator()(const pair<int,int>& lhs,const pair<int,int>& rhs){
            return lhs.second>rhs.second;    //左大于右才是小顶堆，因为根节点要大于插入节点的话就进行交换操作
        }
    };
    
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] ]++;
        //利用比较函数创建优先级队列，第一个是装的元素，第二个实现的容器，这里是vector，deque也可以，第三个比较函数
        priority_queue<pair<int,int>,vector<pair<int,int>>,Mycomparator> pri_que;
        
        //固定大小为k的小顶堆，对map中每一个元素的值进行扫描，找出最大的三个频率
        //遍历hashmap的写法（记一下）
        for(unordered_map<int,int>::iterator it= map.begin();it!=map.end();it++)
        {
            pri_que.push(*it);   //添加的是it的一个指针
            if(pri_que.size()>k)
                pri_que.pop();
        }
        
        vector<int> result(k,0);
        //倒序输出小顶堆
        for(int i=k-1;i>=0;i--)
        {
            result[i] = pri_que.top().first;  //这里用点是因为这是一组数据而非一个find找到的指针
            pri_que.pop();
        }
        return result;
    }
};

时间复杂度：O（nlogk） 

空间复杂度：O（n）

总结

基本的注意事项我都写在注释中了，这边主要还是要理解一下思路，优先级队列的思路

收获

今天依旧在旅游，质量堪忧，继续加油