day10 栈与队列

1.滑动窗口最大值
思路：用队列统计每个窗口最大值，且每次加入队尾的元素要与队列中已有的元素作比较，小的都排出。这里可以引入一个结构：小顶堆。即一个完全二叉树，小的元素放在顶端。

class Solution {
public:
  //  class MyQueue2 { //单调队列（从大到小）
  //   public:
  //       deque<int> que; // 使用deque来实现单调队列
  //       // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
  //       // 同时pop之前判断队列当前是否为空。
  //       void pop(int value) {
  //           if (!que.empty() && value == que.front()) {
  //               que.pop_front();
  //           }
  //       }
  //       // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
  //       // 这样就保持了队列里的数值是单调从大到小的了。
  //       void push(int value) {
  //           while (!que.empty() && value > que.back()) {
  //               que.pop_back();
  //           }
  //           que.push_back(value);

  //       }
  //       // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
  //       int getMaxValue() {
  //           return que.front();
  //       }
  //   };
    class MyQueue
  {
    public:
    deque<int> que;//双向队列
    void pop(int val)
    {
      if(!que.empty()&&val==que.front())
      {
        que.pop_front();//如果pop的元素等于出口元素，则当前元素为最大值
      }
    }
    void push(int val)
    {
      while(!que.empty()&&val>que.back())
      {
        que.pop_back();//如果加入的元素比队列里的数都大，则把队列的数都弹出
      }
      que.push_back(val);//把当前元素加入
    }
    int getMaxValue()
    {
      return que.front();//当前队列出口处为最大值
    }
  };
  
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
      MyQueue que1;
      vector<int> result;
      /*先将前k个元素放入队列*/
      for(int i=0;i<k;i++)
      {
        que1.push(nums[i]);
      }
      result.push_back(que1.getMaxValue());// result 记录前k的元素的最大值
      for(int i=k;i<nums.size();i++)
      {
        que1.pop(nums[i-k]);//如果pop的元素等于出口元素，则当前元素为最大值
        que1.push(nums[i]);//如果加入的元素比队列里的数都大，则把队列的数都弹出
        result.push_back(que1.getMaxValue());
      }
      return result;
    }
};

3.前K个高频元素
思路：题目要求统计前k个出现频率最高的元素。所以我们要统计数组中元素出现的次数最多的前k个元素。
步骤：遍历，用哈希表(map)统计，key存储元素值，value存储次数。再用小顶堆(优先级队列)，存储前k个高频元素，再倒序输出。

class Solution {
public:
    //小顶堆 priority_queue中第三个参数，用来决定元素排序顺序
    class mycomparision{
        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) {
        //1.统计出现的频率
        unordered_map<int,int> map; //key:元素 value；记录频率
        for(int i=0;i<nums.size();i++)
        {
            map[nums[i]]++;
        }
        //2.用小顶堆对频率排序（因为要统计前k个高频的元素，所以用小顶堆将低频的弹出）
        //定义一个小顶堆
        // priority_queue<类型,容器，函数对象>
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparision> pri_que;
        // 用固定大小为k的小顶堆，扫面所有频率的数值 遍历map
        for(unordered_map<int,int>::iterator it = map.begin();it != map.end();it++) 
        {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }
        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for(int i=k-1;i>=0;i--)
        {
            result[i]=pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};