字符串解码

class Solution {
public:
    string decodeString(string s) {
        string res = "";  // 存储当前正在构造的字符串
        stack<int> nums;  // 存储重复次数的栈
        stack<string> strs;  // 存储前面解析好的字符串（当遇到 `[` 时入栈）
        int num = 0;  // 当前解析的数字（重复次数）
        
        int len = s.size();
        for(int i = 0; i < len; ++i) {
            if(s[i] >= '0' && s[i] <= '9') {  
                // 如果当前字符是数字，更新 num，考虑多位数情况
                num = num * 10 + (s[i] - '0');
            }
            else if((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z')) {  
                // 如果是字母，直接拼接到当前的 `res`
                res += s[i];
            }
            else if(s[i] == '[') {  
                // 遇到 `[`，将 `num` 和 `res` 压入栈中
                nums.push(num);  // 存入当前数字
                num = 0;  // 清空 num，开始解析新的部分
                
                strs.push(res);  // 存入当前字符串（存储的是 `[` 之前的内容）
                res = "";  // 清空 res，开始处理 `[...]` 内部的内容
            }
            else if(s[i] == ']') {  
                // 遇到 `]`，表示我们需要将 `[...]` 解析出来
                int times = nums.top();  // 取出栈顶数字（重复次数）
                nums.pop();  // 弹出栈顶数字
                
                // 将 `res` 复制 `times` 次
                string temp = strs.top();  // 取出栈顶字符串（`[` 之前的部分）
                strs.pop();  // 弹出栈顶字符串
                
                for(int j = 0; j < times; ++j) {
                    temp += res;  // 把 `res` 复制 `times` 次，拼接到 `temp`
                }
                
                res = temp;  // 更新 `res`，继续解析后面的字符
            }
        }
        
        return res;  // 返回最终解析的字符串
    }
};

我们以 s = "3[a2[c]]" 作为输入，详细讲解 decodeString 的运行步骤。

你会看到代码在每一步如何修改变量，并最终解码字符串。

---

📌 代码分析

核心思路：

• 用 两个栈 来存储信息：

• nums：存储 [ 之前的数字，表示重复次数。

• strs：存储 [ 之前已经解析的字符串，用于拼接被 [] 括起来的部分。

• 用 两个变量：

• num：存当前数字，表示要重复的次数。

• res：存当前正在构造的字符串。

---

📌 运行步骤

我们来看字符串 s = "3[a2[c]]" 的完整解析过程。

🔹 1. 初始化

nums  = []   (空栈)
strs  = []   (空栈)
num   = 0
res   = ""

---

🔹 2. 遍历字符串

字符	操作	num	res	nums 栈	strs 栈
'3'	解析数字 3	3	""	[]	[]
'['	遇到 [，存储当前 num 和 res，然后清空	0	""	[3]	[""]
'a'	追加到 res	0	"a"	[3]	[""]
'2'	解析数字 2	2	"a"	[3]	[""]
'['	遇到 [，存储当前 num 和 res，然后清空	0	""	[3, 2]	["", "a"]
'c'	追加到 res	0	"c"	[3, 2]	["", "a"]
']'	遇到 ]，弹出 2，重复 "c" 两次，并拼接 "a"	0	"acc"	[3]	[""]
']'	遇到 ]，弹出 3，重复 "acc" 三次	0	"accaccacc"	[]	[]

---

📌 详细解析每一步

1️⃣ 读取 '3'

字符 '3' 是数字，我们累加到 num：

num = 3

---

2️⃣ 读取 '['

[ 代表新的编码块开始，我们：

• 把 num 存入 nums 栈，用于后续重复。

• 把当前 res 存入 strs 栈，因为 res 之后会更新。

• 清空 num 和 res，以便存新内容。

nums = [3]
strs = [""]
num  = 0
res  = ""

---

3️⃣ 读取 'a'

'a' 不是 [ 或 ]，直接追加到 res：

res = "a"

---

4️⃣ 读取 '2'

遇到 '2'，存入 num：

num = 2

---

5️⃣ 读取 '['

新嵌套块开始：

• 把 num 和 res 入栈。

• 清空 num 和 res。

nums = [3, 2]
strs = ["", "a"]
num  = 0
res  = ""

---

6️⃣ 读取 'c'

'c' 是普通字符，追加到 res：

res = "c"

---

7️⃣ 读取 ']'

遇到 ]，我们进行解码：

• 从 nums 弹出 2，表示 res = "c" 需要重复 2 次。

• 从 strs 弹出 "a"，与 "cc" 拼接。

nums = [3]
strs = [""]
res  = "a" + "cc" = "acc"

---

8️⃣ 读取 ']'

再次遇到 ]，进行解码：

• 从 nums 弹出 3，表示 res = "acc" 需要重复 3 次。

• 从 strs 弹出 ""，与 "accaccacc" 拼接。

nums = []
strs = []
res  = "accaccacc"

---

📌 结果

最终，res = "accaccacc"，返回该字符串。

---

📌 复杂度分析

• 时间复杂度：O(N)，每个字符最多入栈和出栈一次。

• 空间复杂度：O(N)，栈最多存储 O(N) 个字符（最坏情况）。

---

📌 总结

✅ 核心思路：

• 遇到 [ 时入栈（存 num 和 res）。

• 遇到 ] 时出栈（弹出 num 进行字符串拼接）。

• 普通字符直接拼接到 res。

✅ 适用于嵌套结构，可以正确处理 "3[a2[c]]"、"2[abc]3[cd]ef" 等复杂情况！🚀