代码随想录打卡第十三天 | 栈与队列 leetcode239&347

目录

 239 - 滑动窗口最大值

1、暴力法-超过时间限制

 2、比较移出的是否为最大-超出时间限制

3、单调队列（deque实现）

 思路：用一个单调队列保存可能为最大值的元素

提交代码 

347 - 前 K 个高频元素

 思路：小顶堆

提交代码

---

 239 - 滑动窗口最大值

1、暴力法-超过时间限制

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int l = 0;
        int r = k - 1;
        vector<int> maxVec;
        int max = 1 << 31;
        while(r < nums.size()){
            for(int i = l; i <= r; ++i){
                max = std::max(max, nums[i]);
            } 
            maxVec.emplace_back(max);      
            max = 1 << 31;
            ++r;
            ++l;   
        }
        return maxVec;
    }
};

 2、比较移出的是否为最大-超出时间限制

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if (k == 1) return nums;

        vector<int> maxVec;
        int max = 1 << 31;
        int lastMax = max;
        nums.insert(nums.begin(), max); //插入哑节点
        int l = 1;
        int r = k;
        while(r < nums.size()){
            if(lastMax == nums[l - 1]){ //移出节点为max
                for(int i = l; i <= r; i++){
                    max = std::max(max, nums[i]);
                }
            }
            else{
                max = std::max(lastMax, nums[r]);
            }

            maxVec.emplace_back(max);
            lastMax = max;
            max = 1 << 31;
            ++r;
            ++l;
        }
        return maxVec;
    }

3、单调队列（deque实现）

 思路：用一个单调队列保存可能为最大值的元素

1、用deque实现；从大到小排列，front为当前滑动窗口的最大值；

2、push时：

        如果val > q.back(), q.back删除，因为val比q.back大，所以q.back不可能是最大值；直到val <= q.back(), 将val压入队列；

3、pop时：

        如果val == q.front(),q.front()删除，因为val已经不在滑动窗口里了，所以要删除；

        如果val!= q.front()，不处理；

提交代码 

class Solution {
public:
    class myque{
    public:
        void push(int val){ //pop所有<val的值，再push_back val
            while(!q.empty() && val > q.back()){
                q.pop_back();
            }
            q.push_back(val);
        }

        void pop(int val){
            if(!q.empty() && val == q.front()){
                q.pop_front();
            }
            else{
            }
        }

        int front(){
            return q.front();
        }

        int back(){
            return q.back();
        }

    private:
        deque<int> q;
    };

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> out;
        myque dq;
        for(int i = 0; i < k; ++i){
            dq.push(nums[i]);
        }
        out.emplace_back(dq.front());
        for(int i = k; i < nums.size(); ++i)
        {
            dq.push(nums[i]);
            dq.pop(nums[i - k]);
            out.emplace_back(dq.front());
        }

        return out;
    }
    void test(){
        vector<int> v  = {7, 2, 4};
        maxSlidingWindow(v, 2);
    }
};

347 - 前 K 个高频元素

 思路：小顶堆

1、统计元素出现频率；容易想到（用unordered_map）

2、对频率排序；（用什么呢??）

3、找出前K个高频元素；

对频率进行排序，这里可以使用一种容器适配器就是优先级队列（priority_queue）!!

优先级队列是什么呢？

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

而且优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？

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

什么是堆呢？

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

此时要思考一下，是使用小顶堆呢，还是大顶堆？

题目要求前 K 个高频元素，那么果断用大顶堆啊。但是如果定义一个大小为k的大顶堆（其实也可以不固定长度为k,最后取的时候取前k个就可以，这种情况不用弹出，就可以使用大顶堆），每次需要弹出时弹出了最大元素，最后就保留不下来前K个高频元素了!

代码使用大小为k的小顶堆，每次长度到k时弹出top(出现频率最小的)；

最后，因为小顶堆每次弹出最小，所以倒序保存在vector中！

提交代码

class Solution {
public:
    class mycomparation{
    public:
        bool operator()(pair<int,int> l, pair<int,int> r){
            return l.second > r.second;
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        for(int i = 0; i < nums.size(); ++i){
            mp[nums[i]]++;
        }

        priority_queue<pair<int,int>, vector<pair<int, int>>, mycomparation> pri_que;
        for(auto it = mp.begin(); it != mp.end(); it++){
            pri_que.push(*it);
            if(pri_que.size() > k){
                pri_que.pop();
            }
        }

        vector<int> vec(k);
        for(int i = k - 1; i >= 0; --i){
            vec[i] = pri_que.top().first;
            pri_que.pop();
        }

        return vec;

    }

    void test(){
        vector<int> v = {1,1,1,2,2,3};
        topKFrequent(v,2);
    }
};