[译]逆波兰表示法

原文链接: Evaluate Reverse Polish Notation

逆波兰表示法是计算一个算法表达式中的值, 有效的运算符有"+", "-", "*", "/"。 每个操作数可能是一个整型或者一个表达式，例如:

   ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
   ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

1. 简单的方法
   这个问题可以用栈来解决，循环每个节点来得到一个数组，当它是数字时，压入栈中；当是运算符的时候，从这个栈中取出两个数来计算，并将两数操作后的结果压入栈中。

图1.png

下面是代码，但是，这段代码存在编译错误，为什么？

public class Test {
    public static void main(String[] args) throws IOException {
        String[] tokens = new String[] { "2", "1", "+", "3", "*" };
        System.out.println(evalRPN(tokens));
    }

    public static int evalRPN(String[] tokens) {
        int returnValue = 0;
        String operators = "+-*/";

        Stack stack = new Stack();

        for (String t : tokens) {
            if (!operators.contains(t)) { // push to stack if it is a number
                stack.push(t);
            } else {// pop numbers from stack if it is an operator
                int a = Integer.valueOf(stack.pop());
                int b = Integer.valueOf(stack.pop());
                switch (t) {
                case "+":
                    stack.push(String.valueOf(a + b));
                    break;
                case "-":
                    stack.push(String.valueOf(b - a));
                    break;
                case "*":
                    stack.push(String.valueOf(a * b));
                    break;
                case "/":
                    stack.push(String.valueOf(b / a));
                    break;
                }
            }
        }

        returnValue = Integer.valueOf(stack.pop());

        return returnValue;
    }
}

问题报错:

Cannot switch on a value of type String for source level below 1.7. 
Only convertible int values or enum variables are permitted

这个问题是由于在switch中使用String的状态只能是在JDK1.7以上。

2. 解决方案
   如果你想去使用switch状态选择，你可以转换为使用一个String "+-*/"的位置标记。

public int evalRPN(String[] tokens) {
 
        int returnValue = 0;
 
        String operators = "+-*/";
 
        Stack stack = new Stack();
 
        for(String t : tokens){
            if(!operators.contains(t)){
                stack.push(t);
            }else{
                int a = Integer.valueOf(stack.pop());
                int b = Integer.valueOf(stack.pop());
                int index = operators.indexOf(t);
                switch(index){
                    case 0:
                        stack.push(String.valueOf(a+b));
                        break;
                    case 1:
                        stack.push(String.valueOf(b-a));
                        break;
                    case 2:
                        stack.push(String.valueOf(a*b));
                        break;
                    case 3:
                        stack.push(String.valueOf(b/a));
                        break;
                }
            }
        }
 
        returnValue = Integer.valueOf(stack.pop());
 
        return returnValue;
 
    }