算法day13-队列

239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

class Solution {
//自己定义一个队列，队列的头元素总是窗口中的最大值
private:
    class MyQueue{
    public:
        //定义个双端队列
        deque<int> que;
        //滑动窗口移动的时候，需要弹出前一个元素
        void pop(int value)
        {
            //因为队列头元素总是最大值，所以当需要弹出的元素等于头元素时，才需要弹出
            //如果不等于的话，则表示需要弹出的元素不是最大元素，在之前的push操作中已经弹出了
            if(!que.empty() && value==que.front())
            {
                que.pop_front();
            }
        }
        //滑动窗口移动添加元素
        void push(int value)
        {
            //如果队列非空，并且添加的元素大于队尾的元素，则弹出队尾的元素
            //直到队尾的元素比添加的元素大，或者队列中没有元素时，就写入元素
            while(!que.empty() && value > que.back())
            {
                que.pop_back();
            }
            que.push_back(value);
        }
        //返回队列的头元素
        int front()
        {
            return que.front();
        }
    };

public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //创建一个对象
        MyQueue que;
        //定义一个一维数组用来存储每一个窗口的最大值
        vector<int> result;
        //先存入前k个元素
        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;
    }
};

347. 前 K 个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

class Solution {
public:
    重写仿函数
    class mycomparion{
    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<Type, Container, Functional> 名称
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparion> pri_que;

        //遍历哈希表
        for(unordered_map<int,int>::iterator iter=map.begin();iter!=map.end();iter++)
        {
            将哈希表中的键对按照小顶堆的方式存取优先级队列
            pri_que.push(*iter);
            //如果队列长度大于k，则弹出元素
            //因为队列是按照小顶堆的方式进行存储，所以弹出的元素是最小的元素
            if(pri_que.size()>k)
            {
                pri_que.pop();
            }
        }
        //定义一个一维数组，用来存储结果
        vector<int> result;
        //因为是小顶堆，倒序遍历队列
        for(int i=k-1;i>=0;i--)
        {
            //top()是队列的头元素，在这里是k个高频元素中，次数最小的的元素
            result.push_back(pri_que.top().first);
            //保存一个结果，队列就弹出一次元素
            pri_que.pop();
        }
        return result;
    }
};