LeetCode Hot100（52/100）——394. 字符串解码

文章目录

• • 一、题目理解
  • • 示例
  • 二、问题分析
  • 三、思维导图
  • 四、方法一：栈解法
  • • 原理说明
    • 执行过程示例（输入："3a2\[c]"）
    • [Java 实现](#Java 实现)
    • 时间复杂度与空间复杂度分析
  • 五、方法二：递归解法
  • • 原理说明
    • 流程图（递归过程）
    • [Java 实现（递归版本）](#Java 实现（递归版本）)
    • 时间复杂度与空间复杂度分析
  • 六、方法对比
  • 七、总结

一、题目理解

题目要求我们对一个编码字符串进行解码 。

编码规则是：

• k[encoded_string] 表示将方括号内部的字符串重复 k 次。
• 示例：3[a2[c]] 的解码结果是 "accaccacc"。

这是一个典型的栈结构混合递归问题，需要处理多层嵌套的结构。

---

示例

输入	输出	解释
"3[a]2[bc]"	"aaabcbc"	"a" 重复 3 次 + "bc" 重复 2 次
"3[a2[c]]"	"accaccacc"	"a2[c]" = "acc" → "acc" 重复 3 次
"2[abc]3[cd]ef"	"abcabccdcdcdef"	按顺序拼接每种模式

---

二、问题分析

该题考察的核心点是：

1. 括号嵌套结构处理
2. 数字与字符串的配对
3. 字符串的重复与拼接

我们可以有两种主要思路：

• 方法一：使用栈模拟解码过程
• 方法二：使用递归处理嵌套结构

---

三、思维导图

Decode String
栈解法
处理数字
处理字母
处理''与''
递归解法
遇到数字时展开递归
遇到']'时返回结果
复杂度分析
时间复杂度 O(n)
空间复杂度 O(n)

---

四、方法一：栈解法

原理说明

我们借助两个栈：

• 数值栈 ：用于存储每次遇到的倍数 k
• 字符串栈：用于存储当前构造的字符串

遇到 [ 时，我们将当前计数与当前字符串入栈；

遇到 ] 时，我们取出栈顶元素进行拼接，实现一层解码。

执行过程示例（输入："3a2\[c]"）

当前指针 数字栈 字符串栈 当前指针 数字栈 字符串栈 读取数字3入栈 读取''，进入新层，当前字符串入栈 遇数字2入栈 遇'\['，进入嵌套层 读取"c"，拼接当前字符串 遇''，出栈2，将"c"重复2次 → "cc" 合并成"a"+"cc" → "acc" 遇']'，出栈3，重复"acc" 3次 → "accaccacc"

Java 实现

public class Solution {
    public String decodeString(String s) {
        // 数值栈
        Stack<Integer> numStack = new Stack<>();
        // 字符串栈
        Stack<StringBuilder> strStack = new Stack<>();
        // 当前字符串
        StringBuilder curr = new StringBuilder();
        int num = 0;

        for (char c : s.toCharArray()) {
            if (Character.isDigit(c)) {
                // 构造多位数字
                num = num * 10 + (c - '0');
            } else if (c == '[') {
                numStack.push(num);
                strStack.push(curr);
                curr = new StringBuilder();
                num = 0;
            } else if (c == ']') {
                StringBuilder prev = strStack.pop();
                int repeat = numStack.pop();
                StringBuilder temp = new StringBuilder();
                for (int i = 0; i < repeat; i++) temp.append(curr);
                curr = prev.append(temp);
            } else {
                curr.append(c);
            }
        }
        return curr.toString();
    }
}

时间复杂度与空间复杂度分析

项目	复杂度
时间复杂度	O(n)（每个字符只被扫描一次）
空间复杂度	O(n)（栈和字符串拼接过程中的存储）

---

五、方法二：递归解法

原理说明

递归方法直接模拟字符串的展开过程：

• 当遇到数字时，记录重复次数；
• 遇到 [ 时进入递归；
• 遇到 ] 时返回当前构造好的字符串。

递归的关键：每次调用只负责处理当前层级的 [...]。

---

流程图（递归过程）

数字
字母

开始 decode
当前字符
构造数字
拼接到结果
进入下一层递归
结束当前递归返回结果
返回构造好的字符串
结束

---

Java 实现（递归版本）

public class Solution {
    private int index = 0;

    public String decodeString(String s) {
        return decode(s);
    }

    private String decode(String s) {
        StringBuilder result = new StringBuilder();
        int num = 0;

        while (index < s.length()) {
            char c = s.charAt(index);

            if (Character.isDigit(c)) {
                num = num * 10 + (c - '0');
                index++;
            } else if (c == '[') {
                index++;
                String sub = decode(s);
                for (int i = 0; i < num; i++) result.append(sub);
                num = 0;
            } else if (c == ']') {
                index++;
                return result.toString();
            } else {
                result.append(c);
                index++;
            }
        }
        return result.toString();
    }
}

时间复杂度与空间复杂度分析

项目	复杂度
时间复杂度	O(n)（每层递归遍历字符串一次）
空间复杂度	O(n)（递归调用栈深度与字符串存储）

---

六、方法对比

特性	栈解法	递归解法
实现难度	较直观	稍复杂
可读性	稍差	清晰
性能	相似	相同
推荐场景	适合迭代逻辑处理	适合表达嵌套结构

---

七、总结

Decode String 是一道经典的括号嵌套与字符串操作题，关键在于：

• 正确处理数字与括号的层级关系；
• 清晰地定义每层的字符串拼接逻辑；
• 合理使用栈或递归结构。