【栈】Leetcode 224. 基本计算器【困难】

基本计算器

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

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

示例 1：

输入：s = “1 + 1”
输出：2

示例 2：

输入：s = " 2-1 + 2 "
输出：3

示例 3：

输入：s = “(1+(4+5+2)-3)+(6+8)”
输出：23

解题思路

• 要实现一个基本计算器（只有加减法和括号）来计算给定的字符串表达式，
• 可以使用栈来处理括号和运算优先级问题（类似 逆波兰表达式，只不过多了一些判断）。

Java实现

public class BasicCalculator {
    public int calculate(String s) {
        Stack<Integer> stack = new Stack<>();
        int result = 0;
        int num = 0;
        int sign = 1; // 1 表示正号, -1 表示负号

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (Character.isDigit(c)) {
                //数字转换
                num = num * 10 + (c - '0');
            } else if (c == '+') {
                //计算要加得数字
                result += sign * num;
                num = 0;
                sign = 1;
            } else if (c == '-') {
                //计算要减的数字
                result += sign * num;
                num = 0;
                sign = -1;
            } else if (c == '(') {
                // 将当前的结果和符号压入栈
                stack.push(result);
                stack.push(sign);
                // 重置结果和符号
                result = 0;
                sign = 1;
            } else if (c == ')') {
                // 先将当前 num 加到 result
                result += sign * num;
                num = 0;
                // 弹出栈顶符号并与当前结果相乘
                result *= stack.pop();
                // 弹出栈顶的之前的结果并相加
                result += stack.pop();
            }
        }

        // 最后一次操作后的结果
        if (num != 0) {
            result += sign * num;
        }

        return result;
    }

    public static void main(String[] args) {
        BasicCalculator calculator = new BasicCalculator();
        System.out.println(calculator.calculate("1 + 1")); // 输出: 2
        System.out.println(calculator.calculate(" 2-1 + 2 ")); // 输出: 3
        System.out.println(calculator.calculate("(1+(4+5+2)-3)+(6+8)")); // 输出: 23
    }
}

时间空间复杂度

• 时间复杂度: O(n)，其中 n 是字符串的长度。每个字符只处理一次。
• 空间复杂度: O(n)，用于存储栈的空间，最坏情况下栈的深度与字符串长度成正比