力扣239. 滑动窗口最大值347. 前 K 个高频元素

239. 滑动窗口最大值(学会单调队列的使用,用deque双端队列来实现单调队列,单调队列就可以保持队列中第一个始终是滑动窗口中的最大值,以此来判断滑动窗口弹出的是不是最大值)

class Solution {
public:
    class Myque
    {   //需要定义一个单调队列(从大到小)
        // 使用deque双端队列来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
        // 同时pop之前判断队列当前是否为空。
        deque<int> que;
        public:
        void push_back(int val)
        {
            while(!que.empty() && que.back()<val)
            {
                que.pop_back();
            }
            que.push_back(val);
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void pop_front(int val)
        {
            if(val == que.front())
            {
                que.pop_front();
            }
        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int maxNum()
        {
            return que.front();
        }
    };

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> arr;
        Myque que;
        for(int i= 0; i<k ; i++)
        {   //先装进前k个元素
            que.push_back(nums[i]);
        }
        arr.push_back(que.maxNum());
        for(int i = 1; i+k <= nums.size(); i++ )
        {   //再进行滑动窗口,每次从单调队列中选出滑动窗口中最大值
            que.push_back(nums[i+k-1]);
            que.pop_front(nums[i-1]);
            arr.push_back(que.maxNum());
        }
        return arr;
    }
};

347. 前 K 个高频元素(优先队列(自动排序)来实现小顶堆(始终是从根节点等于优先队列的front()))

class Solution {
public:
//通过class来重载运算符
    // class myCompare //小顶堆
    // {
    //     public:
    //     bool operator()(const pair<int,int>& ir1 ,const pair<int,int>& ir2 )
    //     {   //为true才将数值顺利往子节点加,否则就是更换父节点,从上往下搭建完全二叉树
    //         return (ir1.second) > (ir2.second);
    //     }
    // };
//通过自定义函数来重载运算符
    static bool op(const pair<int,int>& ir1 ,const pair<int,int>& ir2 )
        {   //自定义函数,但是作为类成员函数时要声明为static
            return (ir1.second) > (ir2.second);
        }

    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> arr;
        unordered_map<int, int> map;
        for(int i = 0; i<nums.size(); i++)
        {
            int num = nums[i];
            auto it = map.find(num);
            if(it == map.end())
            {
                map.emplace(num , 1);
            }
            else
            {
                it->second++;
            }
        }
        //priority_queue<pair<int,int>, vector<pair<int,int> > ,myCompare> que;
        //上面是通过class重载运算符, decltype()是自定义函数的方式
        priority_queue<pair<int,int>, vector<pair<int,int> > ,decltype(&op)> que(op);
        for(unordered_map<int,int>::iterator it = map.begin(); it!=map.end(); it++)
        {
            que.push(*it);
            if(que.size()>k)
            {
                que.pop();
            }
        } 
        while(!que.empty())
        {
            arr.push_back(que.top().first);
            que.pop();
        }
        return arr;
    }
};