代码随想录跟练日记|Day11 栈与队列part02

算法小白训练营日记，笔记为自用，若有错误感谢指出

--今日任务--：150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素

150. 逆波兰表达式求值

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

解题思路：遍历字符串，若为运算符则计算栈中前两个数，若为数字，则将其类型转换为long long压入栈中。

具体代码如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for(auto ch:tokens){
            if(ch=="+"||ch=="-"||ch=="*"||ch=="/"){
                long long nums1=st.top();
                st.pop();
                long long nums2=st.top();
                st.pop();
                if(ch=="+") st.push(nums2+nums1);
                if(ch=="-") st.push(nums2-nums1);
                if(ch=="*") st.push(nums2*nums1);
                if(ch=="/") st.push(nums2/nums1);
            }
            else{
                st.push(stoll(ch));
            }
        }
        int res=st.top();
        return res;
    }
};

239. 滑动窗口最大值

题目链接：239. 滑动窗口最大值 - 力扣（LeetCode）

解题思路：

具体代码如下：本题可用单调队列解决。定义pop函数，如果队列非空并且传入元素等于队首元素值则pop队首元素。定义push函数，若大于队尾元素则删除队尾元素，直到小于等于时将其push进队尾，使其队列一直处于单调递减，因为被移除的元素都比新加入元素小，而队列中元素比较的为滑动窗口所包含k个值的结果，所以被移除元素无论如何都不可能是滑动窗口最大值，只需保证队首元素一直为滑动窗口中最大值。

将数组中元素中前k个调用push函数压进队列中，之后再反复调用pop push，无论是否进出队列，队首元素始终为滑动窗口中最大的，将其存入res数组输出结果即可。

class Solution {
private:
    class MyQueue{
        public:
            deque<int> que;
            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> 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;
    }
};

347.前 K 个高频元素

题目链接：347. 前 K 个高频元素 - 力扣（LeetCode）

解题思路：用unordered_map保存每个元素出现的次数，key为元素值，value为出现次数，直接进行快速排序时间复杂度为O(nlogn)，若运用堆的数据结构，每次只维护k个有序序列，时间复杂度为O(nlogk)。为得到最高频的k值，所以要将最大的value值留在堆中，小的弹出，应该运用小顶堆来实现。优先级队列priority_queue可以直接实现堆，默认实现大顶堆，若是小顶堆需要自定义比较函数。

定义一个结构体Compare并重载operator()，实现比较逻辑return a > b;。在这个比较逻辑中，a > b返回true表示元素a的优先级低于元素b，因此在堆中，a将排在b之后。这种逻辑会导致最小的元素具有最高的优先级，因而形成小顶堆。

std::priority_queue<int, std::vector<int>, Compare> pri_que;

第一个模板参数是堆中元素的类型。第二个模板参数是底层容器类型，默认为std::vector。第三个模板参数是自定义比较函数对象，将std::priority_queue转换为小顶堆。

最后将堆中k个元素的key值存入数组中。

具体代码如下：

class Solution {
public:
    class compare{
    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<pair<int,int>,vector<pair<int,int>>,compare> pri_que;

        for(unordered_map<int,int>::iterator it=map.begin();it!=map.end();it++){
            pri_que.push(*it);
            if(pri_que.size()>k) pri_que.pop();
        }

        vector<int> res(k);
        for(int i=k-1;i>=0;i--){
            res[i]=pri_que.top().first;
            pri_que.pop();
        }
        return res;
    }
};