代码随想录训练营第11天| 150. 逆波兰表达式求值、 239. 滑动窗口最大值-CSDN博客

本文链接：https://blog.csdn.net/m0_61777539/article/details/141487117

一、逆波兰表达式求值

题目链接/文章讲解/视频讲解：代码随想录

1.本题不难，数字入栈（栈为int型），遇到运算符，出栈两个字母，并进行运算，再把结果重新入栈，最后留在栈内的就是结果，注意“-”和“/”是第二个出栈的元素除以第一个出栈的元素

2.stoi 函数：将字符串转成 int 整数。

stol 函数：将字符串转成 long 整数。

stoll 函数：将字符串转成 long long 整数。

本题使用的是istringstream

3.计算机可以利用栈来顺序处理，不需要考虑优先级了。也不用回退（中缀需要考虑计算的顺序括号等）了， 所以后缀表达式对计算机来说是非常友好的。

代码：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {   
        stack<int> st;
        for(int i=0;i<tokens.size();i++)
        {
            if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/")
            {
                int nums1=st.top();
                st.pop();
                int nums2=st.top();
                st.pop();
                if(tokens[i]=="+")
                {
                    st.push(nums1+nums2);
                }
                if(tokens[i]=="-")
                {
                    st.push(nums2-nums1);
                }
                if(tokens[i]=="*")
                {
                    st.push(nums1*nums2);
                }
                if(tokens[i]=="/")
                {
                    st.push(nums2/nums1);
                }
            }
            else
            {   int num=0;
                istringstream ss(tokens[i]);
                ss>>num;
                st.push(num);
            }
        }
        return st.top();

    }
};

二、滑动窗口最大值

题目链接/文章讲解/视频讲解：代码随想录

1.为什么不使用大顶堆，小顶堆（维护k个），因为它们是按照升序或者是降序排序的，pop（）出去的元素不会和题目中pop（）出去的元素一样，这样有一些情况会出错。

2.为什么使用deque双向队列，因为插入元素是和back（）比较（大于则弹出），因为最大的元素在front（）处。pop_front(), pop_back()，第一个元素是最大值

3.本题没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。

而且不要以为实现的单调队列就是对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

单调队列是按数组顺序排序的，删去元素排序

4.pop（）只需要判断front（）处的元素是否和要弹出的元素相等，因为最大值前面的元素都被弹出了，相等说明这个轮到这个最大值弹出了

5.先插入k个，因为是隔k个pop(),队列长度在变

代码：

class Solution {
public:
    class Maxqueue   //维护最大值的单调队列
    {
        public:
        deque<int> qe;
        void pop(int val)
        {
            if(!qe.empty()&&qe.front()==val)
            {
                qe.pop_front();
            }
        }
        void push(int val)
        {
            while(!qe.empty()&&val>qe.back())
            {
                qe.pop_back();
            }
            qe.push_back(val);
        }
        int getMAX()
        {
            return qe.front();
        }
    };
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
            Maxqueue que;
            vector<int> result;
            for(int i=0;i<k;i++)
            {
                que.push(nums[i]);
            }
            result.push_back(que.getMAX());
            for(int i=k;i<nums.size();i++)
            {
                que.pop(nums[i-k]);
                que.push(nums[i]);
                result.push_back(que.getMAX());
            }
            return result;
    }
};

三、前 K 个高频元素

题目链接/文章讲解/视频讲解：代码随想录

1.先用map统计各个元素出现的次数，

2.再对map进行排序，取前k个，所以我们只需要对k个元素进行维护保存，不用全部一块排序，采用优先级队列，大顶堆或小顶堆

3.优先级队列：就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

4.堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值

5.大顶堆：从大到小，小顶堆：从小到大

6.大顶堆pop（）的是最大值，所以本题采用小顶堆.

7.倒序插入，i=k-1

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> mm;
    for(int i=0;i<nums.size();i++)
    {
        mm[nums[i]]++;
    }
    priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
    for (unordered_map<int, int>::iterator it = mm.begin(); it != mm.end(); it++) {
        pri_que.push(*it);
        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;
    }
    
};