栈---字符串解码

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

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

3. 代码实现
   数据结构：重复次数栈，解码字符串栈。
   方法一：
   思路：无迭代，直接拼接到result后；存在迭代，需要暂存字符串到字符串栈。
   若碰到数字时，将"[“之前的数字全部入重复次数栈，若在入栈之前重复次数栈已有元素，表示存在迭代，需要暂存encodedStr字符串到字符串栈，然后将encodedStr置“”；
   若碰到字符，重复次数栈有元素，表示当前字符是需要解码的字符，拼接到encodedStr后；否则直接拼接到result；
   若碰到”]",取重复次数栈栈顶元素k，将encodedStr重复k次；然后判断有无迭代情况，若重复次数栈不空，存在迭代，取字符串栈顶元素与刚刚解码字符串拼接作为encodedStr；无迭代，将刚刚解码字符串拼接到result，置encodedStr为“”。

import java.util.Stack;

public class Solution {
    public String decodeString(String s) {
        String result = "", encodedStr = "";
        Stack<String> stringStack = new Stack<>();
        Stack<Integer> dightStack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) {
                //碰到数字，把]之前数字全部解析
                String num = "";
                while (c != '[') {
                    num += c;
                    i++;
                    c = s.charAt(i);
                }
                //数字栈不为空，表明存在迭代，encodedStr存入字符串栈
                if (!dightStack.empty()) {
                    stringStack.push(encodedStr);
                    encodedStr = "";
                }
                //解析的数字入栈
                dightStack.push(Integer.parseInt(num));
            } else if (c == ']') {
                //数字栈顶元素为重复次数k
                int k = dightStack.pop();
                String str = "";
                for (int j = 0; j < k; j++) {
                    str += encodedStr;
                }
                //存在迭代，取字符串栈顶元素与str拼接，作为当前encodedStr
                if (!dightStack.empty()) {
                    encodedStr = stringStack.pop() + str;
                } else {
                    //无迭代，直接拼接到result，encodeStr置""
                    result += str;
                    encodedStr = "";
                }
            } else {
                //数字栈不为空，表明为需要解码字符串，拼接到encodedStr后
                if (!dightStack.empty()) {
                    encodedStr += c;
                } else {
                    //不需要解码
                    result += c;
                }
            }
        }
        return result;
    }
}

方法二：

class Solution {
    public String decodeString(String s) {
         Stack<String> chars = new Stack<>();
        Stack<Integer> nums = new Stack<>();
        String res = "";
        int num = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c))
                num = num * 10 + (c - '0');
            else if (Character.isLetter(c))
                res += c;
            else if (c == '[') {
                chars.push(res);
                nums.push(num);
                res = "";
                num = 0;
            }
            else {
                int times = nums.pop();
                String temp = "";
                for (int j = 0; j < times; j++) {
                    temp += res;
                }
                res = chars.pop() + temp;
            }
            
        }
        return res;
    }
}