算法-力扣[394] 字符串解码

力扣[394] 字符串解码

题目

给定一个经过编码的字符串，返回它解码后的字符串。编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

示例:

s = "3[a]2[bc]", 返回 "aaabcbc".
s = "3[a2[c]]", 返回 "accaccacc".
s = "2[abc]3[cd]ef", 返回 "abcabccdcdcdef".

题解一：辅助栈

分析

构建两个辅助栈，一个栈stack_res用来存储临时结果，一个栈stack_mul用来存储倍数，遍历字符串 s 中的字符 c ：

• 当 c 为数字时，将数字字符转换为数字 mul，记录为乘数；

• 当 c 为字母时，将字母字符添加到结果字符串 res 的尾部；

• 当 c 为 [ 时，进行入栈操作，将mul 和 res 分别压入栈 stack_mul 和栈 stack_res，同时将乘数 mul 和结果数组 res 分别置为0和空：

  • 乘数 mul 用来记录一会儿出栈时临时结果 res 的倍数；
  • 临时结果 res 记录了一层 [...] 间的字符串，即若把一对 [] 看作一层， res 记录了当前层的字符串；

• 当 c 为 ] 时，进行出栈操作，从栈 stack_mul 和栈 stack_res中分别弹出一个元素为 last_res 和cur_mul ，然后拼接字符串 res = last_res + cur_mul * res：

  • last_res 记录了上一个 [ 到本层 [ 的字符串，即上一层的字符串（不含本层）；
  • 乘数 cur_mul 即栈 stack_mul 刚弹出的元素，用来计算当前层内字符串重复的倍数。

代码实现

class Solution {
    public String decodeString(String s) {
        int mul = 0;
        StringBuilder res = new StringBuilder();
        LinkedList<Integer> stack_mul = new LinkedList<>();
        LinkedList<String> string_mul = new LinkedList<>();
        for (Character c : s.toCharArray()) {
            if (c == '[') {
                stack_mul.addLast(mul);
                string_mul.addLast(res.toString());
                mul = 0;
                res = new StringBuilder();
            } else if (c == ']') {
                int cur_mul = stack_mul.removeLast();
                String last_res = string_mul.removeLast();
                StringBuilder tmp = new StringBuilder();
                for (int i = 0; i < cur_mul; i++) {
                    tmp.append(res);
                }
                res = new StringBuilder(last_res + tmp);
            } else if (c >= '0' && c <= '9') {
                //会存在数字多余1位的情况，比如某字符串重复34次或更多位数
                mul = mul * 10 + Integer.parseInt(c + "");
            } else {
                res.append(c);
            }
        }
        return res.toString();
    }
}

复杂度分析

时间复杂度：只需要遍历一遍s，所以复杂度为O(n)。

空间复杂度：最坏的情况下所有的除 [] 的字符都要入栈，所以空间复杂度最坏为O(n)。