day-13 代码随想录算法训练营（19） 栈和队列part03 已二刷

239.滑动窗口最大值

分析：看数据正常求最大值必然超时

思路：双端队列构成单调队列

class Solution {
private:
    class MyQueue{//单调队列
        public:
            deque<int>que;
 
            void pop(int vaule)
            {
                if(!que.empty() && vaule==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>res;
        for(int i=0;i<k;i++)
        {
            que.push(nums[i]);
        }
        res.push_back(que.front());
 
        for(int i=k;i<nums.size();i++){
            que.pop(nums[i-k]);
            que.push(nums[i]);
            res.push_back(que.front());
        }
        return res;
        
    }
};

照着题解写了一遍，感觉思路能理解，但是实现就懵了

二刷：

思路：优先队列 + pair组合

• 判断当前最大值的索引是否在窗口外
  • 窗口为 k，i-k 就是从 k 开始遍历到了第几个，所以所以必然要大于 i - k
• 最大值的索引在窗口外时，直接弹出

class Solution {
private:
    
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n=nums.size();
        priority_queue<pair<int,int>>que;
        for(int i=0;i<k;i++) que.emplace(nums[i],i);
        vector<int>res;
        res.push_back(que.top().first);
 
        for(int i=k;i<n;i++){
            que.emplace(nums[i],i);
            while(que.top().second<=i-k) que.pop();//判断当前最大值的索引是否过期，不是真正的删除
            res.push_back(que.top().first);
        }
        return res;
    }
};

347.前k个高频元素

之前做过类似的题，但是忘了大小顶堆怎么写了，坐牢！

思路：先记录元素出现的次数，然后加入小顶堆，当小顶对大小大于k时，直接把堆顶元素组排出

class Solution {
public:
    struct cmp{
        bool operator()(const pair<int,int>&map1,const pair<int,int>&map2)
        {
            return map1.second>map2.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<pair<int,int>,vector<pair<int,int>>,cmp>pri_que;
        
        for(auto &[nums,count]:map){
            pri_que.push({nums,count});
            if(pri_que.size()>k){
                pri_que.pop();
            }
        }
 
        vector<int>result(k);
        for(int i=k-1;i>=0;i--)
        {
            result[i]=pri_que.top().first;
            pri_que.pop();
        }
        return result;
        
    }
};

二刷路过