LeetCode394.字符串解码

 这道题有点像我之前写过的一道题有效的括号（不只是栈）-CSDN博客

 但是比那道题要难，但用的方法是一样的，就是用栈的先进后出进行括号匹配，所以有写过之前那道题，这道题按照这个思路走我就写出了如下屎山代码：

class Solution {
    public String decodeString(String s) {
         int n = s.length();
         Stack stack = new Stack<>();
         String ans = "";
         for(int i =0;i

 我这个就非常好理解，遍历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 stack = new Stack<>();
         for(int i =0;i

比如"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 stk = new LinkedList();
        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 sub = new LinkedList();
                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 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() };
    } 
}