LeetCode Basic Calculator II 计算器&栈

思路：

实现计算器的通用解法是2个步骤：
（1）中缀表达式转化为后缀表达式（又叫逆波兰式）：需要 栈 ，栈用来进出运算的符号；

规则如下：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号（乘除优先加减），则栈顶元素依次出栈并输出，成为后缀表达式的一部分，再将当前符号进栈，一直到最终输出后缀表达式为止。

（2）后缀表达式求值：需要 栈 ，栈用来进出运算的数字。

规则如下：从左到右遍历后缀表达式的每个数字和符号，如果遇到数字就进栈，如果遇到符号，就将处于栈顶的两个数字出栈，进行运算（先出栈的是第二个操作符，后出栈的是第一个操作符），再将运算结果进栈，一直到最终获得结果。

按此方法写的code结果TLE了，应该是我的代码不够优化，java code：

public class Solution {
    public int calculate(String s) {
        //中缀表达式转化为后缀表达式
        String rpn = "";
        Stack stack = new Stack();
        int number = 0;
        for(int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            if(Character.isDigit(c)) {
                number = 10 * number + (c - '0');
            }else if(c == '+' || c == '-') {
                rpn += number + " ";
                number = 0;
                while(!stack.empty()) {
                    rpn += stack.peek();
                    stack.pop();
                }
                stack.push(c);
            }else if(c == '*' || c == '/') {
                rpn += number + " ";
                number = 0;
                if(stack.empty()) {
                    stack.push(c);
                }else {
                    if(stack.peek().toString().charAt(0) == '+' || stack.peek().toString().charAt(0) == '-') {
                        stack.push(c);
                    }else {
                        while(!stack.empty() && (stack.peek().toString().charAt(0) == '*' || stack.peek().toString().charAt(0) == '/')) {
                            rpn += stack.peek();
                            stack.pop();
                        }
                        stack.push(c);
                    }
                }
            }
        }
        rpn += number + " ";
        while(!stack.empty()) {
            rpn += stack.peek();
            stack.pop();
        }
        number = 0;
        //后缀表达式求值
        stack = new Stack<Integer>();
        for(int i = 0; i < rpn.length(); ++i) {
            char c = rpn.charAt(i);
            if(Character.isDigit(c)) {
                number = 10 * number + (c - '0');
            }else if(c == ' ') {
                stack.push(number);
                number = 0;
            }else {
                int op2 = Integer.parseInt(stack.peek().toString());
                stack.pop();
                int op1 = Integer.parseInt(stack.peek().toString());
                stack.pop();
                int res = 0;
                switch (c) {
                    case '+':
                        res = op1 + op2;
                        break;
                    case '-':
                        res = op1 - op2;
                        break;
                    case '*':
                        res = op1 * op2;
                        break;
                    case '/':
                        res = op1 / op2;
                        break;
                    default:
                        break;
                }
                stack.push(res);
            }
        }
        int ans = Integer.parseInt(stack.peek().toString());
        return ans;     
    }
}

---

特殊条件特殊对待，所谓的条件就是：没有负数且没有括号。
看了DISCUSS这个答案，牛X。
java code：

class Solution {
    public int calculate(String s) {
        int len;
        if(s==null || (len = s.length())==0) return 0;
        Stack<Integer> stack = new Stack<Integer>();
        int num = 0;
        char sign = '+';
        for(int i=0;i<len;i++){
            if(Character.isDigit(s.charAt(i))){
                num = num*10+s.charAt(i)-'0';
            }
            if((!Character.isDigit(s.charAt(i)) &&' '!=s.charAt(i)) || i==len-1){//第二个 i ＝＝ len－1 用来保证最后一个数字能入栈
                if(sign=='-'){
                    stack.push(-num);
                }
                if(sign=='+'){
                    stack.push(num);
                }
                if(sign=='*'){
                    stack.push(stack.pop()*num);
                }
                if(sign=='/'){
                    stack.push(stack.pop()/num);
                }
                sign = s.charAt(i);
                num = 0;
            }
        }

        int re = 0;
        for(int i:stack){
            re += i;
        }
        return re;
    }
};