解决leetcode150逆波兰表达式

声明：题目来自于leetcode

一、问题描述

150. 逆波兰表达式求值

难度中等612

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

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

示例 2：

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

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

• 1 <= tokens.length <= 104
• tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

• 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
• 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

二、题解：

思路：

通过栈来实现，看到这个题目首先分析逆波兰表达式是一个什么公式，题目公式给出的解析看了也还是不清晰的话那就先结合题目给出的三个例子，来模拟一下，这样子很容易出思路的。

下面就拿第三个例子来手动模拟一下就很容易知道逆波兰表达式是一个什么东西了：

["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
["10","6",(9+3),"-11","*","/","*","17","+","5","+"]
["10","6",((9+3)*-11),"/","*","17","+","5","+"]
["10",(6 / ((9+3)*-11)),"*","17","+","5","+"]
[(10 * (6 / ((9+3)*-11))),"17","+","5","+"]
[((10 * (6 / ((9+3)*-11)))+17),"5","+"]
[(((10 * (6 / ((9+3)*-11)))+17) + 5)]
((10 * (6 / ((9 + 3) * -11))) + 17) + 5

根据这个我们可以想到使用栈来解决这个问题。

就是先来一次编列，对tokens字符串数组进行遍历，对每一个遍历的字符串进行判断：

• 如果是数据，那么就先转换位int类型并且push到栈底
• 如果是算术符号，那么就将栈里的前两个数据pop出来，分别为leftNum和rightNum,这里要区分哪个是第一个哪个是第二个，第一个pop出来的作为rightNum,这是因为如果符号是除法算术符号或者减法算术符号的话就会区分顺序了。letfNum和经过算术运算得到的结果再用push方法压入栈

因为栈来处理的结果会使得栈里最终只剩下一个数据，那个数据就是题目所求。

心得：

遇到这种类使用没见过的公式或者生涩的名词之类的题目一般就先模拟一个例子，很快就摸清楚那些规律的。

解：

class Solution {
    public int evalRPN(String[] tokens) {

        Stack<Integer> stack = new Stack<>();
        for (String s : tokens) {
            if (s.equals("+")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(add(leftNum,rightNum));
            }else if (s.equals("-")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(subtract(leftNum,rightNum));
            }else if (s.equals("*")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(multiply(leftNum,rightNum));
            }else if (s.equals("/")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(Divide(leftNum,rightNum));
            }else {
                int number = Integer.parseInt(s);
                stack.push(number);
            }
        }
        return stack.pop();
    }


    private Integer Divide(int leftNum, int rightNum) {
        return leftNum / rightNum;
    }

    private Integer multiply(int leftNum, int rightNum) {
        return leftNum * rightNum;
    }

    private Integer subtract(int leftNum, int rightNum) {
        return leftNum - rightNum;
    }

    private Integer add(int leftNum, int rightNum) {
        return leftNum + rightNum;
    }
}

化简

class Solution {
    public int evalRPN(String[] tokens) {

        Stack<Integer> stack = new Stack<>();
        for (String s : tokens) {
            if (s.equals("+")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(leftNum + rightNum);
            }else if (s.equals("-")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(leftNum - rightNum);
            }else if (s.equals("*")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(leftNum * rightNum);
            }else if (s.equals("/")){
                int rightNum = stack.pop();
                int leftNum = stack.pop();
                stack.push(leftNum / rightNum);
            }else {
                int number = Integer.parseInt(s);
                stack.push(number);
            }
        }
        return stack.pop();
    }
}

但是该题解还不是最优的,

运行结果：

好家伙，这么快做出了的解果然不行。

但是思路应该是最优了呀，于是就想到了可能是equals的前后顺序不一样，或者说其他的还有其他更好的api的调用。后面去看了其他人的题解发现和xin麒想象的一样。

如下：下面这个代码的思路和xin麒的是一样的

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for (String s : tokens) {
            if ("+".equals(s)) {       
                stack.push(stack.pop() + stack.pop());     
            } else if ("-".equals(s)) {
                stack.push(-stack.pop() + stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop() * stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.parseInt(s));
            }
        }
        return stack.pop();
    }
}

五万没想到的就是就最多优化1ms看来也就这样：