LeetCode 394：字符串解码

今天的题目来源于 LeetCode 第 394 号问题：字符串编码，难度为「中等」，根据评论区的反馈，近期华为面试、字节面试都出现过。

一、题目描述

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为:k[encoded_string]，表示其中方括号内部的encoded_string正好重复k次。注意k保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数k，例如不会出现像3a或2[4]的输入。

示例 1：

输入：s ="3[a]2[bc]"
输出："aaabcbc"

示例 2：

输入：s ="3[a2[c]]"
输出："accaccacc"

示例 3：

输入：s ="2[abc]3[cd]ef"
输出："abcabccdcdcdef"

示例 4：

输入：s ="abc3[cd]xyz"
输出："abccdcdcdxyz"

提示：

• 1 <= s.length <= 30
• s由小写英文字母、数字和方括号'[]'组成
• s保证是一个有效的输入。
• s中所有整数的取值范围为[1, 300]

二、题目解析

注意示例 2 ，可以发现字符串中存在括号内有嵌套括号的情况，这个时候，只有先把内层括号解码成功，才能再去解码外层括号。

也就意味着后面访问的括号比前面访问的括号还更早的进行处理，与栈的先入后出特点对应。

所以，本题使用栈来处理。

具体操作如下：

1、构建两个栈，一个是数字栈numStack，在遍历编码字符串过程中记录出现的数字；一个是字符串栈strStack，在遍历编码字符串过程中记录出现的字符串。

2、初始化两个变量，一个是digit，用来记录访问到字符串之前出现的数字；一个是res，在访问编码字符串的过程中，把得到的结果存放到 res 中。

3、接下来，开始从头到尾访问编码字符串，在访问过程中，字符会出现 4 种情况。

4、如果是数字，需要把字符转成整型数字，然后更新到digit上，代表后续的字符串需要重复digit次。

5、如果是字符，说明它就出现一次，可以直接存放到 res 中。

6、如果是"[" ，这个时候出现了嵌套的内层编码字符串，而外层的解码需要等待内层解码的结果，那么之前已经扫描的字符需要存放起来，等到内层解码之后再重新使用。

7、如果是"]" ，此时，内层解码已经有结果，需要把它和前面的字符串进行拼接。

8、拼接的方式就是先通过 numsStack 的栈顶元素获取重复的次数，再通过 strStack 的栈顶元素获取前面的字符串。

9、最后返回 res 就行。

三、参考代码

1、Java 代码

//登录AlgoMooc官网获取更多算法图解
//https://www.algomooc.com
//作者：程序员吴师兄
//代码有看不懂的地方一定要私聊咨询吴师兄呀
//字符串解码(LeetCode394)//leetcode.cn/problems/decode-string/
classSolution{
publicStringdecodeString(Strings){

//创建数字栈，在遍历编码字符串过程中记录出现的数字
DequenumStack=newLinkedList<>();

//创建字符栈，在遍历编码字符串过程中记录出现的字符串
DequestrStack=newLinkedList<>();

//在访问编码字符串的过程中，用来记录访问到字符串之前出现的数字，一开始为0
intdigit=0;

//在访问编码字符串的过程中，把得到的结果存放到res中
StringBuilderres=newStringBuilder();

//从头到尾遍历编码字符串
for(inti=0;i< s.length(); i++) {

            //在遍历过程中，字符会出现4种情况

//先获取此时访问的字符
charch=s.charAt(i);

//1、如果是数字，需要把字符转成整型数字
//注意数字不一定是1位，有可能是多位
//比如123a，在字母a的前面出现了123，表示a重复出现123次
//那么一开始ch为1，当访问到ch为2的时候，1和2要组成数字12
//再出现3，12和3组成数字123
if(Character.isDigit(ch)){

//先将字符转成整型数字ch-‘0’
//补充知识：将字符'0'-'9'转换为数字，只需将字符变量减去'0'就行
//因为字符和数字在内存里都是以ASCII码形式存储的
//减去'0'，其实就是减去字符'0'的ASCII码，而字符'0'的ASCII码是30
//所以减去'0'也就是减去30，然后就可以得到字符对应的数字了。
intnum=ch-'0';

//再将这个数字和前面存储的数字进行组合
//1和2组成数字12，也就是1*10+2=12
//12和3组成数字123，也就是12*10+3=123
digit=digit*10+num;

//2、如果是字符
}elseif((ch>='a'&&ch<= 'z')){

//说明它就出现一次，可以直接存放到res中
res.append(ch);

//3、如果是"["
//出现了嵌套的内层编码字符串，而外层的解码需要等待内层解码的结果
//那么之前已经扫描的字符需要存放起来，等到内层解码之后再重新使用
}elseif(ch=='['){

//把数字存放到数字栈
numStack.push(digit);

//把外层的解码字符串存放到字符串栈
strStack.push(res);

//开始新的一轮解码
//于是，digit归零
digit=0;

//res重新初始化
res=newStringBuilder();

//4、如果是"]"
}elseif(ch==']'){

//此时，内层解码已经有结果，需要把它和前面的字符串进行拼接

//第一步，先去查看内层解码的字符串需要被重复输出几次
//比如e3[abc]，比如内层解码结果abc需要输出3次
//通过数字栈提取出次数
intcount=numStack.poll();

//第二步，通过字符串栈提取出之前的解码字符串
StringBuilderoutString=strStack.poll();

//第三步，不断的把内层解码的字符串拼接起来
for(intj=0;j< count; j++) {
                    
                    //拼接到outString后面，拼接count次
outString.append(res.toString());
}

//再把此时得到的结果赋值给res
res=outString;
}
}

//返回解码成功的字符串
returnres.toString();
}
}

2、C++ 代码

classSolution{
public:
stringdecodeString(strings){
//创建数字栈，在遍历编码字符串过程中记录出现的数字
stack<int>numStack;

//创建字符栈，在遍历编码字符串过程中记录出现的字符串
stack<string>strStack;

//在访问编码字符串的过程中，用来记录访问到字符串之前出现的数字，一开始为0
intdigit=0;

//在访问编码字符串的过程中，把得到的结果存放到res中
stringres;

//从头到尾遍历编码字符串
for(inti=0;i< s.size(); i++) {

            //在遍历过程中，字符会出现4种情况

//先获取此时访问的字符
charch=s[i];
//1、如果是数字，需要把字符转成整型数字
//注意数字不一定是1位，有可能是多位
//比如123a，在字母a的前面出现了123，表示a重复出现123次
//那么一开始ch为1，当访问到ch为2的时候，1和2要组成数字12
//再出现3，12和3组成数字123
if(ch>='0'&&ch<='9'){

//先将字符转成整型数字ch-‘0’
//补充知识：将字符'0'-'9'转换为数字，只需将字符变量减去'0'就行
//因为字符和数字在内存里都是以ASCII码形式存储的
//减去'0'，其实就是减去字符'0'的ASCII码，而字符'0'的ASCII码是30
//所以减去'0'也就是减去30，然后就可以得到字符对应的数字了。
intnum=ch-'0';

//再将这个数字和前面存储的数字进行组合
//1和2组成数字12，也就是1*10+2=12
//12和3组成数字123，也就是12*10+3=123
digit=digit*10+num;

//2、如果是字符
}elseif((ch>='a'&&ch<= 'z')){

//说明它就出现一次，可以直接存放到res中
res+=ch;

//3、如果是"["
//出现了嵌套的内层编码字符串，而外层的解码需要等待内层解码的结果
//那么之前已经扫描的字符需要存放起来，等到内层解码之后再重新使用
}elseif(ch=='['){

//把数字存放到数字栈
numStack.push(digit);

//把外层的解码字符串存放到字符串栈
strStack.push(res);

//开始新的一轮解码
//于是，digit归零
digit=0;

//res重新初始化
res="";

//4、如果是"]"
}elseif(ch==']'){

//此时，内层解码已经有结果，需要把它和前面的字符串进行拼接

//第一步，先去查看内层解码的字符串需要被重复输出几次
//比如e3[abc]，比如内层解码结果abc需要输出3次
//通过数字栈提取出次数
intcount=numStack.top();

numStack.pop();

//第二步，通过字符串栈提取出之前的解码字符串
stringoutString=strStack.top();

strStack.pop();

//第三步，不断的把内层解码的字符串拼接起来
for(intj=0;j< count; j++) {
                    
                    //拼接到outString后面，拼接count次
outString+=res;
}

//再把此时得到的结果赋值给res
res=outString;
}
}

//返回解码成功的字符串
returnres;
}
};

3、Python 代码

classSolution:
defdecodeString(self,s:str)->str:
#创建数字栈，在遍历编码字符串过程中记录出现的数字
numStack=[]

#创建字符栈，在遍历编码字符串过程中记录出现的字符串
strStack=[]

#在访问编码字符串的过程中，用来记录访问到字符串之前出现的数字，一开始为0
digit=0

#在访问编码字符串的过程中，把得到的结果存放到res中
res=""

#从头到尾遍历编码字符串
forchins:

#在遍历过程中，字符会出现4种情况
#先获取此时访问的字符
#1、如果是数字，需要把字符转成整型数字
#注意数字不一定是1位，有可能是多位
#比如123a，在字母a的前面出现了123，表示a重复出现123次
#那么一开始ch为1，当访问到ch为2的时候，1和2要组成数字12
#再出现3，12和3组成数字123
if'0'<= ch <= '9':

#先将字符转成整型数字ch-‘0’
#补充知识：将字符'0'-'9'转换为数字，只需将字符变量减去'0'就行
#因为字符和数字在内存里都是以ASCII码形式存储的
#减去'0'，其实就是减去字符'0'的ASCII码，而字符'0'的ASCII码是30
#所以减去'0'也就是减去30，然后就可以得到字符对应的数字了。
num=int(ch)

#再将这个数字和前面存储的数字进行组合
#1和2组成数字12，也就是1*10+2=12
#12和3组成数字123，也就是12*10+3=123
digit=digit*10+num

#2、如果是字符
elifch>='a'andch<= 'z':

#说明它就出现一次，可以直接存放到res中
res+=ch

#3、如果是"["
#出现了嵌套的内层编码字符串，而外层的解码需要等待内层解码的结果
#那么之前已经扫描的字符需要存放起来，等到内层解码之后再重新使用
elifch=='[':

#把数字存放到数字栈
numStack.append(digit)

#把外层的解码字符串存放到字符串栈
strStack.append(res)

#开始新的一轮解码
#于是，digit归零
digit=0

#res重新初始化
res=""

#4、如果是"]"
elifch==']':

#此时，内层解码已经有结果，需要把它和前面的字符串进行拼接

#第一步，先去查看内层解码的字符串需要被重复输出几次
#比如e3[abc]，比如内层解码结果abc需要输出3次
#通过数字栈提取出次数
count=numStack.pop()

#第二步，通过字符串栈提取出之前的解码字符串
outString=strStack.pop()

#第三步，不断的把内层解码的字符串拼接起来
forjinrange(0,count):
#拼接到outString后面，拼接count次
outString+=res


#再把此时得到的结果赋值给res
res=outString

#返回解码成功的字符串
returnres

四、复杂度分析

• 时间复杂度 O(N)，一次遍历s
• 空间复杂度 O(N)，辅助栈在极端情况下需要线性空间。

审核编辑 ：李倩