逆波兰表达式求值（后缀表达式求值）

题目描述：

根据 逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
注意 两个整数之间的除法只保留整数部分。
可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = [“2”,“1”,"+",“3”,"*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = [“4”,“13”,“5”,"/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

解题思路：
1.遇到操作数，入栈
2.遇到操作符，就把栈顶的数据，拿出来运算，将结果入栈

中缀转后缀：
1.遇到操作数输出（或储存）
2.遇到操作符，若栈为空，入栈；若这个操作符比栈顶的优先级高，入栈
3.栈不为空，这个操作符比栈顶的优先级低或相等，出栈顶的运算符，这个操作符（低级操作符）入栈
4.直到中缀表达式结束

class Solution {
public:
    void getOPNum(stack<int>& st,int& left,int& right)
    {
        right = st.top();
        st.pop();
        left = st.top();
        st.pop();
    }
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(const auto& str:tokens)
        {
            int left,right;
            switch(str[0])
            {
                case '+':
                    getOPNum(st,left,right);
                    st.push(left+right);
                    break;
                case '-':
                    if(str.size() == 1)   //考虑负数
                    {
                        getOPNum(st,left,right);
                        st.push(left-right);
                        break;
                    }
                    else
                    {
                        st.push(stoi(str));  //是负数则转为整型
                    }
                    break;
                    
                case '*':
                    getOPNum(st,left,right);
                    st.push(left*right);
                    break;
                case '/':
                    getOPNum(st,left,right);
                    st.push(left/right);
                    break;
                default:
                     st.push(stoi(str));//字符串转整型
                break;
            }
        }
        return st.top();
    }
};

或者直接取str的后面的数，忽略负数的符号

class Solution {
public:
    void getOPNum(stack<int>& st,int& left,int& right)
    {
        right = st.top();
        st.pop();
        left = st.top();
        st.pop();
    }
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(const auto& str:tokens)
        {
            int left,right;
            switch(str.back())
            {
                case '+':
                    getOPNum(st,left,right);
                    st.push(left+right);
                    break;
                case '-':
                    getOPNum(st,left,right);
                    st.push(left-right);
                    break;
                case '*':
                    getOPNum(st,left,right);
                    st.push(left*right);
                    break;
                case '/':
                    getOPNum(st,left,right);
                    st.push(left/right);
                    break;
                default:
                     st.push(stoi(str));//字符串转整型
                break;
            }
        }
        return st.top();
    }
};