算法通关村第四关 | 表达式问题

1. 计算器问题。

LeetCode227：实现一个计算器

简单的说就是将加、减、乘、除都转换成加法，遍历整个字符串，用preSign记录每个数字之前的运算符，第一个数字之前我们默认视为加，根据preSign决定运算方式，计算压入的值，压入后的值最后做加法运算

加号：将数字压入栈，减号：将数字的相反数压入栈，乘除号：与数字栈顶元素计算，并将栈顶元素替换为计算结果，代码实现中，若读到一个运算符，会计算上个数字与上个运算符的运算 ，当遍历到运算符或读到数字末尾的时候，则进行运算，读到数字末尾的时候要进行最后一次运算，

遍历完之后将栈中所有元素相加

代码

    public int calculate(String s){
        ArrayDeque<Integer> stack = new ArrayDeque<>();
        //第一个字符之前视为加号，做加运算
        char preSign = '+';
        int num = 0;
        int n = s.length();
        for (int i = 0; i < n; i++) {
            //isDigigit判断是不是字符是不是数字，是返回true
            if (Character.isDigit(s.charAt(i))){
                num = num * 10 + s.charAt(i) - '0';
            }
            //当到最后一个数字的时候i = n - 1;则if里面条件满足，进行最后一次运算
            if (!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ' || i == n - 1){
                switch (preSign){
                    case '+':
                        stack.push(num);
                        break;
                    case '-':
                        stack.push(-num);
                        break;
                    case '*':
                        stack.push(stack.pop() * num);
                        break;
                    default:
                        stack.push(stack.pop() / num);
                }
                preSign = s.charAt(i);
                num = 0;
            }
        }
        int ans = 0;
        //对栈中所有元素求和，返回和
        while (!stack.isEmpty()){
            ans += stack.pop();
        }
        return ans;
    }

2.逆波兰表达式

逆波兰表达式就是二叉树的后序遍历。LeetCode150：

 

这里只研究后缀表达式，代码就是取出栈中最上面的两个元素进行计算，最后将计算结果入栈

    public int evalRPN(String[] tokens){
        Stack<Integer> stack = new Stack<>();
        for (String token : tokens
        ){
            //判断是否是运算符，不是则入栈
            if (!Character.isDigit(token.charAt(0)) && token.length() == 1){
                //运算符，从栈中取出两个数进行运算
                int b = stack.pop();
                int a = stack.pop();
                switch (token){
                    case "+":
                        stack.push(a + b);
                        break;
                    case "-":
                        stack.push(a - b);
                        break;
                    case "*":
                        stack.push(a * b);
                        break;
                    case "/":
                        stack.push(a / b);
                        break;
                }
            }else {
                //直接入栈
                stack.push(Integer.parseInt(token));
            }
        }
        return stack.pop();
    }