LeetCode——字符串解码

Q：给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: 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"

A：
递归：
从左向右解析字符串：

• 如果当前位置为数字位，那么后面一定包含一个用方括号表示的字符串，即属于这种情况：\(k[...]\)：
  - 我们可以先解析出一个数字，然后解析到了左括号，递归向下解析后面的内容，遇到对应的右括号就返回，此时我们可以根据解析出的数字 \(x\) 解析出的括号里的字符串 \(s'\) 构造出一个新的字符串 \(x \times s'\) ;
  - 我们把 \(k[...]\) 解析结束后，再次调用递归函数，解析右括号右边的内容。
• 如果当前位置是字母位，那么我们直接解析当前这个字母，然后递归向下解析这个字母后面的内容。

    public String decodeString(String s) {
        if (s.length() <= 1)
            return s;
        String res = decodeSubString(1, s);
        return res;
    }

    private String decodeSubString(int n, String s) {
        StringBuilder decode = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char curr = s.charAt(i);
            if (curr >= '0' && curr <= '9') {
                int j = i + 1;
                while (s.charAt(j) != '[') {
                    j++;
                }
                int number = Integer.parseInt(s.substring(i, j));//数字
                int left = j + 1;
                int right = left;
                int count = 1;
                while (count > 0) {
                    char temp = s.charAt(right);
                    if (temp == '[') {
                        count++;
                    } else if (temp == ']') {
                        count--;
                    }
                    right++;
                }
                right--;
                String inside = s.substring(left, right);//该数字后括号内的substring
                String res = decodeSubString(number, inside);
                decode.append(res);
                i = right;
            } else {
                decode.append(curr);
            }
        }
        decode.append(String.valueOf(decode).repeat(Math.max(0, n - 1)));
        return decode.toString();
    }

栈：

• 如果当前的字符为数位，解析出一个数字（连续的多个数位）并进栈
• 如果当前的字符为字母或者左括号，直接进栈
• 如果当前的字符为右括号，开始出栈，一直到左括号出栈，出栈序列反转后拼接成一个字符串，此时取出栈顶的数字（此时栈顶一定是数字，想想为什么？），就是这个字符串应该出现的次数，我们根据这个次数和字符串构造出新的字符串并进栈

    public String decodeString(String s) {
        if (s.length() <= 1)
            return s;
        StringBuilder res = new StringBuilder();
        Stack<Character> stack = new Stack<>();
        int index = 0;
        while (index < s.length()) {
            char curr = s.charAt(index);
            if (curr != ']') {
                stack.add(curr);
            } else {
                StringBuilder decode = new StringBuilder();
                while (stack.peek() != '[') {
                    decode.insert(0, stack.pop());
                }
                stack.pop();
                StringBuilder num = new StringBuilder();
                while (!stack.empty() && stack.peek() >= '0' && stack.peek() <= '9') {
                    num.insert(0, stack.pop());
                }
                int number = Integer.parseInt(num.toString());
                StringBuilder decodeSub = new StringBuilder();
                decodeSub.append(String.valueOf(decode).repeat(Math.max(0, number)));
                for (int i = 0; i < decodeSub.length(); i++) {
                    stack.add(decodeSub.charAt(i));
                }
            }
            index++;
        }
        while (!stack.empty()) {
            res.insert(0, stack.pop());
        }
        return res.toString();
    }