栈的运算器、逆波兰式计算

计算器

leetcode227

给与字符串表达式s="3+2*2"

输出7

读取到运算符进行运算前需要得到两个数字，preSign先为'+'，将第一个数字和0进行相加的和num后压入栈,再读取后一个运算符preSign = 新的运算符，继续读取下一个数字，根据preSign运算后压入栈。

加减运算直接用x和-x入栈，乘除运算需要和输出的栈顶元素进行运算后入栈。

最后栈中只剩加法。

    public static int calculate(String s){
        Deque<Integer> stack = new ArrayDeque<>();
        char preSign = '+';
        int num = 0;
        int n = s.length();
        for (int i = 0; i < n;++i){
            if (Character.isDigit(s.charAt(i))){
                num = num*10+s.charAt(i)-'0';
            }
            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;
                    case '/':
                        stack.push(stack.pop()/num);
                        break;
                }
                preSign= s.charAt(i);
                num=0;
            }
        }
        int ans = 0;
        while (!stack.isEmpty()){
            ans +=stack.pop();
        }
        return ans;
    }

逆波兰式

逆波兰式按顺序运算，将数字入栈，读取到运算符就pop()两次得到要运算的两个数字，在将运算结果入栈。

     public static int evalRPN(String s){
        Character character = null;
        int n = s.length();
        Stack<Integer> stack = new Stack<>();
        for (int i = 0;i < n;i++){
            character = s.charAt(i);
            if (Character.isDigit(character)){
                stack.push(character-'0');
            }else {
                int lastNum = stack.pop();
                int preNum = stack.pop();
                switch (character){
                    case '+':
                        stack.push(lastNum+preNum);
                        break;
                    case '-':
                        stack.push(preNum-lastNum);
                        break;
                    case '*':
                        stack.push(preNum*lastNum);
                        break;
                    case '/':
                        stack.push(preNum/lastNum);
                        break;
                }
            }
        }
        if (!stack.isEmpty()){
            return stack.pop();
        }
        return 0;
    }