LeetCode394 字符串解码

题目

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: 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"

方法

两个栈

首先定义两个栈，一个保存字符串的个数，一个保存当前字符串的前边的字符串，遍历字符串，根据4种不同的字符情况定义操作

• 时间复杂度：O（）
• 空间复杂度：O（）

class Solution {
    public String decodeString(String s) {
        StringBuffer ans=new StringBuffer(); //存放当前字符串
        Stack<Integer> multiStack=new Stack<>();//存放字符串的个数数字
        Stack<StringBuffer> ansStack=new Stack<>();//存放当前字符串之前的字符
        int multi=0;//计算当前数字的值，将字符串变为数字
        for(char c:s.toCharArray()){
            if(Character.isDigit(c))
                multi=multi*10+c-'0'; //如果字符串为数字 ，转为int型，*10是多位连续数字
            else if(c=='['){
                ansStack.add(ans);//如果当前字符为[，说明数字结束，将当前字符串的数字保存入栈，将当前字符串之前的字符串保存入栈，将数字清0
                multiStack.add(multi);
                ans=new StringBuffer();
                multi=0;
            }else if(Character.isAlphabetic(c)){ //是不是字母
                ans.append(c); //如果是字母，则依次把字符放入当前字符串
            }else{   //如果是]，则把当前字符串的数字拿出来，把之前的字符串拿出来，在之前的字符串中加入多个当前字符串，然后把当前字符串替换成已经添加好的字符串
                StringBuffer ansTmp=ansStack.pop();
                int tmp=multiStack.pop();
                for(int i=0;i<tmp;i++)
                    ansTmp.append(ans);
                ans=ansTmp;
            }
        }
        return ans.toString();
    }
}

栈方法

使用辅助栈，遍历字符串
若当前字符为数字，则记录后面紧跟的所有数字拼成字符串存入栈
若当前字符为字母或[，则直接入栈
若当前字符为]，则出栈直到第一个[，将出栈的字符存入另一个栈中，并去除[，取出数字拼成解码的字符串存入栈中
（这里使用另一个栈而不使用StringBuffer是因为出栈的不一定是单个字符，有可能是已解码的字符串，此时用StringBuffer并反转顺序就不对了）

• 时间复杂度：O（）
• 空间复杂度：O（）

class Solution {
    private int ptr;
    public String decodeString(String s) {
        LinkedList<String> stack  = new LinkedList<>();
        ptr = 0;
        while(ptr<s.length()){
            char c = s.charAt(ptr);
            if(Character.isDigit(c)){
                StringBuffer numBuf = new StringBuffer();
                while(Character.isDigit(s.charAt(ptr))){
                    numBuf.append(s.charAt(ptr++));
                }
                stack.addLast(numBuf.toString());
            }else if(Character.isLetter(c)||c=='['){
                stack.addLast(String.valueOf(s.charAt(ptr++)));
            }else{
                ptr++;
                LinkedList<String> str = new LinkedList<>();
                while(!stack.peekLast().equals("[")){
                    str.addLast(stack.removeLast());
                }
                stack.removeLast();
                Collections.reverse(str);
                String val = getString(str);
                StringBuffer vals = new StringBuffer();
                int num = Integer.parseInt(stack.removeLast());
                for(int i=0;i<num;i++){
                    vals.append(val);
                }
                stack.addLast(vals.toString());
            }
        }
        String ans = getString(stack);
        return ans;
    }
    private String getString(LinkedList<String> stack){
        StringBuffer ans = new StringBuffer();
        for(String s:stack){
            ans.append(s);
        }
        return ans.toString();
    }
}