【c++刷题笔记-栈和队列】day12： 150. 逆波兰表达式求值 、239. 滑动窗口最大值 、 347.前 K 个高频元素

150. 逆波兰表达式求值 - 力扣（LeetCode）

思路：使用栈，把数字入栈遇到符号就弹出两个栈元素，再把计算好的元素入栈，到最后栈里只剩余一个元素就是答案

重点：每个字符是string类型，需要使用string来接受，stoi()库函数string类型转int类型

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int>st;
        for(string s:tokens){
            if(s=="+"||s=="-"||s=="*"||s=="/"){
                int a=st.top();
                st.pop();
                int b=st.top();
                st.pop();
                if(s=="+"){
                    st.push(b+a);
                }else if(s=="-"){
                    st.push(b-a);
                }else if(s=="*"){
                    st.push(b*a);
                }else if(s=="/"){
                    st.push(b/a);
                }
            }else{
                st.push(stoi(s));//stoi():string转int
            }
        }
        return st.top();
    }
};

239. 滑动窗口最大值 - 力扣（LeetCode）

思路：单调队列，固定窗口大小，利用队列的单调性队头元素就是当前窗口的最大值

重点：双端队列的使用，什么时候该移除元素需要弄清楚

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if(nums.size()==0||k==0){
            return {};
        }
        int n=nums.size();
        deque<int>deque;
        vector<int>ans(n-k+1);
        //k=j-i保持滑动窗口为k大小
        for(int j=0,i=1-k;j<nums.size();i++,j++){
            //如果前一个为前一个窗口最大的元素则移除这个元素
            if(i>0&&deque.front()==nums[i-1]){
                deque.pop_front();
            }
            //保持单调递减
            while(!deque.empty()&&deque.back()<nums[j]){
                deque.pop_back();
            }
            deque.push_back(nums[j]);
            //队头第一个为最大值
            if(i>=0){
                ans[i]=deque.front();
            }
        }
        return ans;
    }
};

347. 前 K 个高频元素 - 力扣（LeetCode）

思路：优先队列（大根堆和小根堆），先使用哈希表统计频率，再建立大小为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) {
        unordered_map<int,int>hash;
        for(int a:nums){
            hash[a]++;
        }
        //priority_queue<数据类型,容器类型（必须是用数组实现的容器）,自定义排序（默认大顶堆）>
        //pair<int,int>数对，第一个代表频率，第二个代表元素
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison>que;
        for(auto it=hash.begin();it!=hash.end();it++){
            que.push(*it);
            if(que.size()>k){//保持当前的小顶堆只有k个
                que.pop();
            }
        }
        vector<int>ans(k);
        //倒序排序，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        for(int i=k-1;i>=0;i--){
            ans[i]=que.top().first;
            que.pop();
        }
        return ans;
    }
};

总结

掌握栈和队列的使用，双端队列的特性和优先队列的特性要弄清楚