LeetCode 224. 基本计算器：手写实现加减+括号运算

LeetCode 上的经典栈应用题——224. 基本计算器，这道题的核心是实现一个支持 加减运算、括号、空格 的简易计算器，并且明确禁止使用 eval() 等内置表达式计算函数，完全需要我们手动解析字符串、处理运算逻辑。

很多同学遇到这道题会头疼，尤其是括号带来的运算优先级问题，今天就结合完整可运行的代码，从题目理解到代码拆解，一步步讲清楚每一步的逻辑，新手也能轻松看懂！

一、题目回顾（LeetCode 224. 基本计算器）

题目描述

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

注意：

• 表达式 s 只包含数字、‘+’、‘-’、‘(’、‘)’ 和空格 ’ '；

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

• 示例：输入 “(1+(4+5+2)-3)+(6+8)”，输出 23；输入 " 2-1 + 2 "，输出 3。

题目核心难点

这道题的难点不在于加减运算本身，而在于两个点：

二、核心解题思路

解决这道题的最优思路是使用 栈（Stack） 来保存计算过程中的状态，核心逻辑围绕「括号优先级」和「符号处理」展开：

简单来说：栈的作用就是「暂存括号外的上下文」，让我们可以专注于括号内的计算，计算完成后再回退到之前的上下文继续运算。

三、完整代码实现（TypeScript）

先上完整可运行的代码，后面逐行拆解每一步逻辑，确保每一行代码都讲明白：

function calculate(s: string): number {
const stack: number[] = [];
let num = 0;
let sign = '+'; // 当前数字的符号（+/-）
let result = 0; // 当前层级（括号内/外）的计算结果

for (let i = 0; i < s.length; i++) {
const c = s[i];

// 1. 解析多位数（比如"123" -> 123）
if (c >= '0' && c<= '9') {
num = num * 10 + (c.charCodeAt(0) – '0'.charCodeAt(0));
}

// 2. 处理左括号：保存当前状态（结果、符号）到栈，重置状态计算括号内的值
if (c === '(') {
stack.push(result); // 保存括号外的结果
stack.push(sign === '+' ? 1 : –1); // 保存括号前的符号（用1/-1代替+/-更方便）
// 重置状态，开始计算括号内的子表达式
result = 0;
sign = '+';
}

// 3. 处理运算符（+/-）或右括号：结算当前数字
if ((c === '+' || c === '-') || i === s.length – 1 || c === ')') {
// 根据当前符号，把数字加到结果中
result += sign === '+' ? num : –num;
num = 0; // 重置临时数字

// 更新符号（仅当是+/-时）
if (c === '+' || c === '-') {
sign = c;
}

// 4. 处理右括号：弹出栈中保存的状态，合并结果
if (c === ')') {
const prevSign = stack.pop()!; // 括号前的符号（1/-1）
const prevResult = stack.pop()!; // 括号外的结果
result = prevResult + prevSign * result; // 合并括号内和括号外的结果
}
}

// 空格直接跳过，无需处理
}

return result;
}

四、代码逐行拆解（核心逻辑精讲）

我们按「初始化变量 → 遍历字符串 → 各场景处理 → 最终返回结果」的顺序，逐块拆解代码，重点讲清楚栈的用法和括号处理逻辑。

1. 初始化变量（关键变量说明）

const stack: number[] = []; // 栈：保存括号外的计算状态（结果+符号）
let num = 0; // 临时变量：拼接多位数（如"123"，先算1，再12，最后123）
let sign = '+'; // 符号变量：记录当前数字的符号（默认+，因为第一个数字隐含正号）
let result = 0; // 结果变量：记录当前层级（括号内/外）的计算结果

这里有个小细节：sign 记录的是「当前数字的符号」，而不是「上一个运算符」，这样处理能更方便地对接多位数解析和括号逻辑，后面会看到具体作用。

2. 遍历字符串（核心循环）

循环的核心是「逐个处理字符」，根据字符的类型（数字、左括号、右括号、运算符、空格），执行不同的逻辑，我们逐个场景分析：

场景1：解析多位数（字符是 0-9）

if (c >= '0' && c <= '9') {
num = num * 10 + (c.charCodeAt(0) – '0'.charCodeAt(0));
}

这行代码是「多位数拼接」的关键，举个例子：解析 “123” 时：

• 遇到 ‘1’：num = 0 * 10 + (49 – 48) = 1（字符 ‘0’ 的 ASCII 码是 48，‘1’ 是 49）；

• 遇到 ‘2’：num = 1 * 10 + (50 – 48) = 12；

• 遇到 ‘3’：num = 12 * 10 + (51 – 48) = 123；

这样就完成了多位数的正确拼接，避免把 “123” 解析成 1、2、3 三个单独的数字。

场景2：处理左括号 ‘(’

if (c === '(') {
stack.push(result); // 保存括号外的结果
stack.push(sign === '+' ? 1 : –1); // 保存括号前的符号（用1/-1代替+/-）
// 重置状态，开始计算括号内的子表达式
result = 0;
sign = '+';
}

这是括号处理的核心步骤之一，目的是「暂存括号外的上下文」，举个例子：当遇到表达式 “(1 + 2) – 3” 中的 ‘(’ 时：

为什么用 1/-1 代替 ‘+’/‘-’？因为后续合并括号内外结果时，直接用「括号外结果 + 括号前符号 × 括号内结果」就能快速计算，无需再判断符号字符串，更简洁。

场景3：处理运算符（+/-）、右括号 ‘)’ 或字符串末尾

这部分是「结算当前数字」的核心，当遇到以下三种情况时，说明当前数字已经解析完成，需要把它加到 result 中：

• 遇到运算符 ‘+’ 或 ‘-’（下一个数字要开始解析，当前数字需要结算）；

• 遇到右括号 ‘)’（括号内的数字解析完成，需要结算后和括号外合并）；

• 遍历到字符串末尾（最后一个数字没有后续运算符，需要结算）。

if ((c === '+' || c === '-') || i === s.length – 1 || c === ')') {
// 步骤1：根据当前符号，把数字加到结果中
result += sign === '+' ? num : –num;
num = 0; // 重置临时数字，准备解析下一个数

// 步骤2：更新符号（仅当当前字符是+/-时）
if (c === '+' || c === '-') {
sign = c;
}

// 步骤3：处理右括号，合并括号内外结果
if (c === ')') {
const prevSign = stack.pop()!; // 弹出括号前的符号（1/-1）
const prevResult = stack.pop()!; // 弹出括号外的结果
result = prevResult + prevSign * result; // 合并结果
}
}

我们分步骤拆解这部分逻辑，还是用例子辅助理解：

例子1：解析 “1 + 2” 时，遇到 ‘+’ 运算符：

• 此时 num = 1（已经解析完第一个数字），sign = ‘+’；

• result += 1 → result = 1；

• num 重置为 0，sign 更新为 ‘+’（当前运算符）；

• 继续解析下一个数字 2，后续遇到字符串末尾时，再把 2 加到 result 中，最终 result = 3。

例子2：解析 “(1 + 2) – 3” 时，遇到 ‘)’ 右括号：

• 括号内已经解析完 “1 + 2”，此时 result = 3，num = 0；

• 弹出栈顶的 prevSign = 1（括号前是正号），再弹出 prevResult = 0（括号外的结果）；

• 合并结果：result = 0 + 1 × 3 = 3；

• 继续解析后续的 ‘-’ 和 3，最终 result = 3 – 3 = 0。

场景4：处理空格（直接跳过）

代码中没有专门写空格的处理逻辑，因为当 c 是空格时，不满足任何一个 if 条件，会直接进入下一次循环，相当于「自动跳过」，逻辑简洁高效。

3. 最终返回结果

循环结束后，result 中就保存了整个表达式的计算结果，直接返回即可：return result;

五、总结与优化思考

1. 核心知识点回顾

这道题的核心是「栈的应用」，用栈暂存括号外的上下文，解决括号优先级问题，同时用三个变量（num、sign、result）维护当前计算状态，高效解析多位数和符号。

关键亮点：

• 用 1/-1 代替 ‘+’/‘-’ 符号，简化括号内外结果的合并逻辑；

• 一次遍历完成所有解析和计算，时间复杂度 O(n)（n 是字符串长度）；

• 栈的空间复杂度最坏 O(n)（嵌套括号层数最多为 n/2），属于最优解法。

2. 优化方向（可选）

如果想进一步优化代码，可以考虑：

• 用正则表达式先过滤掉所有空格，减少循环中的判断（但会增加一次正则遍历，整体效率影响不大）；

• 对于嵌套括号极深的场景，栈的空间开销无法避免，这是该思路的固有特性，也是最优选择。

3. 刷题启示

遇到「优先级处理」「上下文暂存」类的算法题，优先考虑栈这种数据结构（比如括号匹配、表达式求值等）。这道题虽然是中等难度，但覆盖了栈的核心用法、多位数解析、符号处理等多个细节，吃透这道题，能轻松应对同类的表达式求值问题（如 LeetCode 227. 基本计算器 II，支持乘除运算）。