这道题有点像我之前写过的一道题有效的括号（不只是栈）-CSDN博客
但是比那道题要难，但用的方法是一样的，就是用栈的先进后出进行括号匹配，所以有写过之前那道题，这道题按照这个思路走我就写出了如下屎山代码：
class Solution {
public String decodeString(String s) {
int n = s.length();
Stack<Character> stack = new Stack<>();
String ans = "";
for(int i =0;i<n;i++){
char c = s.charAt(i);
if(c != ']'){
stack.push(c);
}else{
String tmp = "";
while(!stack.isEmpty()){
char c1 = stack.pop();
if(c1 != '['){
tmp = c1 + tmp;
}else{
int num = stack.pop() -48;
int m =1;
while(!stack.isEmpty() && stack.peek() <= 57){
int mask = (int)Math.pow(10,m);
num = num + (int)(stack.pop() -48)*mask;
m++;
}
char[] charArr = tmp.toCharArray();
for(int k =0;k<num;k++){
for(int j=0;j<charArr.length;j++){
stack.push(charArr[j]);
}
}
break;
}
}
}
}
while(!stack.isEmpty()){
ans = stack.pop() + ans;
}
return ans;
}
}我这个就非常好理解，遍历s的每个字符，只要不是“]”就直接放；如果是那么就从stack里面把字符拿出来拼接，如果拿出来的这个字符是"[",那么再把[前面的数字拿出来(可能是多位数)num，然后把这个把这个拼接出来的字符串一位一位的放回stack，放num遍，遍历完了s所有的字符之后，把stack里面的字符连起来就是ans，返回ans即可。
比如“3[a2[c]]”，一开始stack里面放的是3[a2[c，然后遇到了],就把c拿出来，把2*c放回去，现在stack里面是3[acc，然后又遇到了],把acc拿出来，把3*acc放回去，stack里面现在是accaccacc，遍历完了返回accaccacc。
因为效率有点慢只超过了11%，我就想能不能拿到括号里的字符串就不放回stack了，于是我把放回stack那一部分改成了递归写了如下代码：
class Solution {
public String decodeString(String s) {
if(!s.contains("[")){
return s;
}
int n = s.length();
Stack<Character> stack = new Stack<>();
for(int i =0;i<n;i++){
char c = s.charAt(i);
if(c != ']'){
stack.push(c);
}else{
String tmp = "";
while(!stack.isEmpty()){
char c1 = stack.pop();
if(c1 != '['){
tmp = c1 + tmp;
}else{
int num = 0;
int m =0;
String p = "";
while(!stack.isEmpty() && stack.peek() <= 57){
int mask = (int)Math.pow(10,m);
num = num + (int)(stack.pop() -48)*mask;
m++;
}
p = tmp;
for(int k =0;k<num-1;k++){
tmp += p;
}
s= s.substring(0,i-1-p.length()-m) + tmp + s.substring(i+1,n);
if(s.contains("[")){
return decodeString(s);
}else{
return s;
}
}
}
}
}
return s;
}
}比如"3[a2[c]]"，stack里面是3[a2[c，然后遇到了],于是拿出了cc,然后把s变成“3[a” + “cc” + "]"也就是“3[acc]”。然后再判断“3[acc]”里面有没有“[”,如果没有说明全部括号都消掉了，直接返回这个s即如果还有括号，则递归调用decodeString(s)再消掉一个括号。算法没问题，但是没软用，依旧是超过11%。
看看题解做法吧。
题解的做法一和我第一种的思想是一样的就是从stack中拿出来字符串后乘以倍数又返回栈，但是它的的效率超过了77%，它相比于我就是一点优化，它stack放的是String而我放的是char，所以它遍历到一个字母字符后就把后面连串的字符拼接放进去。比如“100[leetcode]”,我是放了100个[l,e,e,t,c,o,d,e]而它放的是100个leetcode,无论是空间还是时间都效率更高，以下是题解方法一代码：
class Solution {
int ptr;
public String decodeString(String s) {
LinkedList<String> stk = new LinkedList<String>();
ptr = 0;
while (ptr < s.length()) {
char cur = s.charAt(ptr);
if (Character.isDigit(cur)) {
// 获取一个数字并进栈
String digits = getDigits(s);
stk.addLast(digits);
} else if (Character.isLetter(cur) || cur == '[') {
// 获取一个字母并进栈
stk.addLast(String.valueOf(s.charAt(ptr++)));
} else {
++ptr;
LinkedList<String> sub = new LinkedList<String>();
while (!"[".equals(stk.peekLast())) {
sub.addLast(stk.removeLast());
}
Collections.reverse(sub);
// 左括号出栈
stk.removeLast();
// 此时栈顶为当前 sub 对应的字符串应该出现的次数
int repTime = Integer.parseInt(stk.removeLast());
StringBuffer t = new StringBuffer();
String o = getString(sub);
// 构造字符串
while (repTime-- > 0) {
t.append(o);
}
// 将构造好的字符串入栈
stk.addLast(t.toString());
}
}
return getString(stk);
}
public String getDigits(String s) {
StringBuffer ret = new StringBuffer();
while (Character.isDigit(s.charAt(ptr))) {
ret.append(s.charAt(ptr++));
}
return ret.toString();
}
public String getString(LinkedList<String> v) {
StringBuffer ret = new StringBuffer();
for (String s : v) {
ret.append(s);
}
return ret.toString();
}
}
题解方法二用的是递归：
class Solution {
public String decodeString(String s) {
return dfs(s, 0)[0];
}
private String[] dfs(String s, int i) {
StringBuilder res = new StringBuilder();
int multi = 0;
while(i < s.length()) {
if(s.charAt(i) >= '0' && s.charAt(i) <= '9')
multi = multi * 10 + Integer.parseInt(String.valueOf(s.charAt(i)));
else if(s.charAt(i) == '[') {
String[] tmp = dfs(s, i + 1);
i = Integer.parseInt(tmp[0]);
while(multi > 0) {
res.append(tmp[1]);
multi--;
}
}
else if(s.charAt(i) == ']')
return new String[] { String.valueOf(i), res.toString() };
else
res.append(String.valueOf(s.charAt(i)));
i++;
}
return new String[] { res.toString() };
}
}
