代码随想录算法训练营第13天|239滑动窗口最大值 347 前K个高频元素

239 滑动窗口最大值

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

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

这是一个困难题，确实挺难的。

解题思路：

1. 看到本题时，脑子里首先跳出来的解法是采用优先队列。
   优先队列是一种特殊的队列，可以看做是堆的线性存储
   优先队列的实质是对队列里的数据进行排序。在本题中，采用优先队列带来的问题是，仅仅通过一个存储int的优先队列无法做到相应的事情，因为在滑动窗口的时候，我们需要将窗口前端的值给去除，但在优先队列中，我们无法知道哪一个元素是窗口前部的值。但是采用优先队列也有相应的解决方法，通过pair<int,int>的方式将value和index加入即可，不过得重新写排序规则。
2. 因此在优先队列使用较为繁琐的情况下，采用自定义的单调序列。在单调序列中，我们不需要对队列里的数据进行排序，而是直接通过push和pop，使得存入队列里的数据就是单调的。

/***
采用单调队列的方法，单调减序列，队列的出口元素必须是最大值。
解释：队列出口元素：就是队列front的元素，要弹出的地方。
队列入口元素：就是队列back的元素，是作为队列入口进入的地方。
因此，对于pop和push方法就比较关键。
pop:如果队列不为空并且弹出的值等于队列出口元素的值(之所以需要弹出的时候做判断，是为了保证滑动窗口里的数量,确保在pop出去的值是需要离开窗口的)
push：如果压入的值大于队列入口的值，则将队列里的值弹出，直到push的值小于等于队列入口位置的值。
**/
class Solution {
private:
    class MyQueue{ //内部类
    public:
        deque<int>que;//使用deque实现单调队列
        void pop(int value){
            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;
       for(int i=0;i<k;i++) //先将前K个元素，存入队列中
       {
           que.push(nums[i]);
       }
       result.push_back(que.front());//队列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;
    }
};

前K个高频元素

题目链接：添加链接描述
题目描述：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

解题思路：
这题跟上一题不一样，这题明确表示，需要对其进行排序，因此，我们要选择前面讲到的优先序列。

1. 首先需要确定优先队列的最大堆还是最小堆，这边采用最小堆，队列按从小到大的顺序排列。
2. 确定好大小堆之后，确定队列的大小，因为要K个，所以队列有K个就行了。

/***这题与上题不一样，采用优先队列的做法

**/
class Solution {
public:
    class myComparison{
        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) {
        priority_queue <pair<int,int>,vector<pair<int,int>>,myComparison >q;//默认是小顶堆
        unordered_map<int,int>map;//存储key和次数
        vector<int>result(k);
        for(int num:nums)
        {
            map[num]++;
        }
        for(auto iter=map.begin();iter!=map.end();iter++)
        {
            q.push(*iter);
            if(q.size()>k)  q.pop();
        }
        for(int i=k-1;i>=0;i--)
        {
            result[i]=q.top().first;
            q.pop();
        }
        return result;

    }
};