【算法训练】LeetCode#227 基本计算器 II

一、描述

227. 基本计算器 II

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。

注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。

示例 1：

输入：s = "3+2*2"
输出：7

示例 2：

输入：s = " 3/2 "
输出：1

示例 3：

输入：s = " 3+5 / 2 "
输出：5

二、思路

• 利用栈，先算x、/再算+、-，毕竟这道题还没有涉及到括号，不用考虑太多。
• 我真是笑死，说着不用考虑太多，结果因为空格问题调了半天，然后写了个屎山...
• 因为是屎山，所以有了第二个版本，其实思路是相同的，只是第一个版本的实现方式太垃圾了。。

三、解题

public static class Solution {
    // 屎山
    public int calculate(String s) {
        if (s == null || s.length() == 0){
            return 0;
        }
        s = s.replace(" ","");
        char[] chars = s.toCharArray(); // 逐字符遍历
        Stack<Integer> stack = new Stack<>();
        int[] cur= {0,0};
        while (cur[1] < chars.length){
            cur = getNum(chars,cur[1]);
            if (cur[0] != -6 && cur[0] != -1){
                // 除了乘除，都直接入栈
                stack.push(cur[0]);
                continue;
            }
            // 如果是乘除
            int operation = cur[0]; // 得到操作符
            int leftNum = stack.pop(); // 得到左数
            cur = getNum(chars,cur[1]); // 得到右数
            int rightNum = cur[0];
            stack.push(operation == -6 ? leftNum*rightNum : (int)(leftNum/rightNum));
        }
        Stack<Integer> newStack = new Stack<>();
        while (!stack.isEmpty()){
            newStack.push(stack.pop());
        }
        int sum = newStack.pop();
        while (!newStack.isEmpty()){
            int operation = newStack.pop(); // 得到操作符
            int rightNum = newStack.pop(); // 得到右树
            sum = operation == -5 ? sum+rightNum : sum-rightNum;
        }
        return sum;
    }

    // 从loc位置开始返回连续数字构成的真实数字以及下一位索引
    public int[] getNum(char[] chars,int loc){
        int num = chars[loc]-'0';
        if (num < 0){
            return new int[]{num, loc+1}; // -5 + 、 -3 - 、 -6 * 、 -1 /
        }
        while (loc+1<chars.length){
            // 如果存在下一位
            if (chars[loc+1]-'0' > -1){
                // 如果是数字
                num = num*10 + (chars[loc+1]-'0');
                loc++;
            } else {
                break;
            }
        }
        return new int[]{num, loc+1}; // -5 + 、 -3 - 、 -6 * 、 -1 /
    }
    
    // 优化
    public int calculateV2(String s) {
        char[] chars = s.toCharArray();
        int num = 0;
        char operation = '+'; // 存储前一步操作符
        Stack<Integer> stack = new Stack<>();
        for (int i = 0 ; i < chars.length ; i++){
            // 遍历
            if (chars[i]-'0' > -1){
                // 如果是数字
                num = num *10 + (chars[i]-'0');
            }
            if ((chars[i]-'0' < 0 && chars[i] != ' ') || i == chars.length-1){
                // 根据前一步操作符将num入栈
                switch (operation){
                    case '+':stack.push(num);break; // + 直接入
                    case '-':stack.push(-num);break; // - 入负num
                    case '*':stack.push(stack.pop() * num);break; // * 入乘法结果
                    case '/':stack.push((int)stack.pop() / num);break; // + 入除法结果
                }
                switch (chars[i]-'0'){
                        // 更新操作符
                    case -5:operation = '+';break;
                    case -3:operation = '-';break;
                    case -6:operation = '*';break;
                    case -1:operation = '/';break;
                }
                num = 0;
            }
        }
        num = 0;
        while (!stack.isEmpty()){
            num += stack.pop();
        }
        return num;
    }
}