代码随想录|day13| 栈与队列part03 ● 239. 滑动窗口最大值● 347.前 K 个高频元素● 总结

239. 滑动窗口最大值--------知识点：单调队列

链接：代码随想录

 自己写的，报错：

class DandiaoQueue{
    //一个栈或者队列，基本要有进栈出栈两种操作，这里再加上pop出最大值一种操作
    //底层是deque
public:
    deque<int>d;
    void pop(int x)
    {
        if(d.front()==x)
        {
            d.pop_front();
        }
    }
    void push(int x)
    {
        while(!d.empty()&& d.back()<x)//需要加等号吗？应该不用吧，不是严格单调递减
        {
            d.pop_back();
        }
        d.push_back(x);

    }

    int get_max()
    {
       return d.front();
    }

};


class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        DandiaoQueue MyQueue;
        vector<int>res;//记录每k个元素的最大值
        int n=nums.size();
        int i=0;
        while(i<n && i<k)
        {
            MyQueue.push(nums[i]);
            i++;
        }

        for(int i=k;i<n;i++)
        {
            MyQueue.push(nums[i]);
            MyQueue.pop(nums[i-k]);

             res.push_back(MyQueue.get_max());
        }
        return res;


    }
};

看了之前写的：

发现少了

没有把第一个最大值放进res ，更正后正确。

更正后代码：

class Solution {
private:
     //创建单调队列的class
     class DandiaoQueue{
         public:
            deque<int>d;//底层实现
            void push(int x)
            {
                while(!d.empty()&&x>d.back())
                {
                    d.pop_back();
                }
                d.push_back(x);

            }
            void pop(int left)
            {
                if(left==d.front())
                {
                    d.pop_front();
                }

            }
            int maxx()
            {
                return d.front();
            }
           
     };
public:
/*
总的来说，结合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
和https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-daeca/dan-diao-d-32cd5/ 来理解

单调队列用到压扁的比喻让人印象深刻
单调队列、单调栈、滑动窗口、优先队列 区别
现在需要一种新的队列结构，既能够维护队列元素「先进先出」的时间顺序，又能够正确维护队列中所有元素的最值，这就是「单调队列」结构
队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列

不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。
*/
   
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        DandiaoQueue myque;
        vector<int>res;//res中存储当前滑动窗口最大值
        int n=nums.size();
        //先把k个元素送进单调队列
        int i=0;
        while(i<k)
        {
            myque.push(nums[i]);
            i++;
        }
        res.push_back(myque.maxx());
        //接下来维护大小为k的滑动窗口，保证进一个新元素，走一个滑动窗口中的元素----这里卡住了，怎么接着往下写？
        for(i=k;i<n;i++)
        {
            myque.pop(nums[i-k]);//如果不是不做任何处理
            myque.push(nums[i]);
            res.push_back(myque.maxx());
        }
        return res;

    }
};

347.前 K 个高频元素 -------------自定义的优先队列

链接：代码随想录

 之前写的，小白友好：

class Solution {
/*我都不知道自己之前怎么做对的，这感觉也不像单调队列啊，我可以用vector<pair<int,int>>存储所有元素和对应的频率值，然后sort寻找前k个频率最高的元素

啊，是优先队列，我命运般的优先队列
关于优先队列的基本知识可以看这一篇：https://leetcode.cn/problems/top-k-frequent-elements/solutions/1283998/c-xiao-bai-you-hao-you-xian-dui-lie-de-j-53ay/

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
*/
public:
   class myCompare{
 public://不加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) {
        vector<pair<int,int>>v;
        vector<int>res;
        unordered_map<int,int>m;
        for(auto num:nums)
        {
            m[num]++;
        }
        //map m={每个元素：对应的频率}
        //要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。
        //将 m中的pair加入优先队列，并维持优先队列大小为k（自定义）
        priority_queue<pair<int,int>,vector<pair<int,int>>,myCompare>q;

        for(auto p: m)
        {
            q.push(p);
            if(q.size()>k)
            {
                q.pop();
            }
        }

        while(!q.empty())
        {
            //pair<int,int> top=q.front();
            pair<int,int> top=q.top();
            res.push_back(top.first);
            q.pop();
        }

        return res;

    }
};

二刷：

class Solution {
/*
优先队列:默认为大顶堆，每次pop出堆中最大值，所以是从大到小

本题保存最终的k个大值，所以要pop的是每次的最小值，用小根堆，小根堆关键词greater<int>
同时因为这道题堆中的排列顺序不是按照值，而是按照频率，必须要用pair<int,int>作为每个节点的基础，且优先队列中
的序列为vector<pair<int,int>>,值和频率事先统计好（怎么统计，用unordered_map）
*/
struct MyCompare{
     bool operator()(pair<int,int> &a, pair<int,int> &b)
    {
        return a.second>b.second;
    }
};
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        priority_queue<pair<int,int>,vector<pair<int,int>>,MyCompare>myqueue;
        vector<int>res;//保存前k个频率最大的值

        //先统计所有值和对应的频率,用unordered_map
        unordered_map<int,int>umap;
        for(auto num:nums)
        {
            umap[num]++;
        }

        //写MyCompare 自定义比较函数
        int n=nums.size();
       
        for(auto p:umap)
        {
             myqueue.push(p);
            if(myqueue.size()>k)
            {
                myqueue.pop();
            }
        }

        while(!myqueue.empty())
        {
            res.push_back(myqueue.top().first);
            myqueue.pop();
        }
        return res;

    }
};