150. 逆波兰表达式求值

150. 逆波兰表达式求值
逆波兰表达式的优点：

题目解析：题目就是要求给你一个逆波兰表达式，然后你算出其表达式的值，我们直接用栈进行模拟。
思路：我们遍历字符串，然后将字符串元素判断，如果是数字，则入栈，如果是算符，则取出栈顶两个元素进行计算，并将计算结果压入栈中。
当遍历完字符时，返回栈中的元素（即最终结果）

但是要注意细节，就是在减法和除法的顺序上

这三道题目，用栈，分别是相邻元素消除、相邻元素匹配、相邻元素运算

代码实现

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<Integer>();
        int n = tokens.length;
        for (int i = 0; i < n; i++) {
            String token = tokens[i];
            if (isNumber(token)) {
                stack.push(Integer.parseInt(token));
            } else {
                int num2 = stack.pop();
                int num1 = stack.pop();
                switch (token) {
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }
            }
        }
        return stack.pop();
    }

    public boolean isNumber(String token) {
        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/solution/ni-bo-lan-biao-da-shi-qiu-zhi-by-leetcod-wue9/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二（最优解）：

class Solution {
    public int evalRPN(String[] tokens) {
             //1.定义一个栈，用来存储操作数
        Stack<Integer> oprands = new Stack<>();
        //2.从左往右遍历逆波兰表达式，得到每一个元素

        for (int i = 0; i < tokens.length; i++) {
            String curr = tokens[i];
  //3.判断当前元素是运算符还是操作数
            Integer o1;
            Integer o2;
            Integer result;

            switch (curr) {
                case "+":
                    //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结果再压入栈中
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 + o1;
                    oprands.push(result);
                    break;
                case "-":
                    //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结果再压入栈中
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 - o1;
                    oprands.push(result);
                    break;
                case "*":
                    //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结果再压入栈中
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 * o1;
                    oprands.push(result);
                    break;
                case "/":
                    //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结果再压入栈中
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 / o1;
                    oprands.push(result);

                    break;
                default:
                    //5.操作数，把该操作数放入到栈中；
                    oprands.push(Integer.parseInt(curr));
                    break;
            }

        }


        //6.得到栈中最后一个元素，就是逆波兰表达式的结果
        int result = oprands.pop();

        return result;
    
    }
}

相关链接：
[1]代码随想录
[2] 官方解答视频
[3] Java中String、char数组和int之间的互相转换
[3.1] 字符型String 转换为 Integer类型
[3.2] string数组和char数组,二者不同，不要混为一谈
[4] 8种基本数据类型和引用数据类型
[4.1] int 和Integer区别
[4.2] equals和==区别
[5] 增强for循环、switch条件语句、if条件语句