华为OD机试 - 简单的解压缩算法

题目描述

现需要实现一种算法，能将一组压缩字符串还原成原始字符串，还原规则如下：

1、字符后面加数字N，表示重复字符N次。例如：压缩内容为A3，表示原始字符串为AAA。

2、花括号中的字符串加数字N，表示花括号中的字符重复N次。例如压缩内容为{AB}3，表示原始字符串为ABABAB。

3、字符加N和花括号后面加N，支持任意的嵌套，包括互相嵌套，例如：压缩内容可以{A3B1{C}3}3

输入描述

输入一行压缩后的字符串

输出描述

输出压缩前的字符串

备注

• 输入保证，数字不会为0，花括号中的内容不会为空，保证输入的都是合法有效的压缩字符串

• 输入输出字符串区分大小写

• 输入的字符串长度范围为[1, 10000]

• 输出的字符串长度范围为[1, 100000]

• 数字N范围为[1, 10000]

用例

输入	{A3B1{C}3}3
输出	AAABCCCAAABCCCAAABCCC
说明	{A3B1{C}3}3代表A字符重复3次，B字符重复1次，花括号中的C字符重复3次，最外层花括号中的AAABCCC重复3次。

package com.itheima.华为机考;

import java.util.LinkedList;
import java.util.Scanner;

/**
 * @author guts
 * @Date 2023/2/24 16:14
 * @Version 1.0
 * 简单的解压缩算法
 */
public class HW060 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.next();
            LinkedList<String> stack = new LinkedList<>();
            //stack的预处理，最后还是要进行一次getStr,因为最后一个字符很有可能不是}，而只有字符为}，才会调用getStr方法
            //并且最后getStr方法需要{字符作为结束
            stack.addFirst("{");
            char[] chars = s.toCharArray();
            int idx = 0;
            while (idx < chars.length) {
                //如果该字符不是}则直接入栈
                if (chars[idx] != '}') {
                    stack.addFirst(String.valueOf(chars[idx]));
                    idx++;
                } else {
                    //idx++,表示跳过}字符，一般来说}后面会跟着数字，如果有数字，将数字统计，调用getStr方法，进行字符串拼接并将字符串重新入栈
                    idx++;
                    StringBuilder sb = new StringBuilder();
                    while (idx<chars.length&&Character.isDigit(chars[idx])) {
                        sb.append(chars[idx]);
                        idx++;
                    }
                    //如果sb的长度为0，表示，}后不跟随数字，数字默认为1，如果跟随数字，则跟随上数字
                    int num = sb.length() == 0 ? 1 : Integer.parseInt(sb.toString());
                    getStr(stack, num);
                }
            }
            getStr(stack,1);
            System.out.println(stack.peekFirst());
        }
    }

    private static void getStr(LinkedList<String> stack, int num) {
        //栈中只有0或一个字符串，不进行处理
        if(stack.size()<=1)return;
        StringBuilder sb = new StringBuilder();
        //辅助栈，为了保证{}内的正向顺序，需要一个栈用来调整顺序
        LinkedList<String> stack2=new LinkedList<>();
        //stack的栈顶不是{，就一直执行，意思是对括号内的字符串进行拼接处理
        while (!stack.isEmpty() && !stack.peekFirst().equals("{")) {
            //栈顶的字符串，可能是数字，拼接过的长字符串，和单字母
            String s = stack.removeFirst();
            //表示单字符，可能是数字或者字母，字母就直接append，数字的话，需要统计数字的大小
            if(s.length()==1){
                //数字，使用stringBuilder拼接数字，reverse调整他的顺序
                //数字的话得一直从stack中弹字符串，因为{}后的数字再调用getStr时都被我们处理掉了，所以不会出现数字后跟一个已经处理过的拼接字符串的情况
                if(Character.isDigit(s.charAt(0))){
                    StringBuilder sb2=new StringBuilder();
                    sb2.append(s);
                    while(Character.isDigit(stack.peekFirst().charAt(0))){
                        sb2.append(stack.removeFirst());
                    }
                    //数字前的字母的重复个数
                    int count=Integer.parseInt(sb2.reverse().toString());
                    //因为输入不会出现非法输入，例如{22},这种情况出现,不过也可以进行以下处理
                    String s1="";
                    if(!stack.peekFirst().equals("{"))s1 = stack.removeFirst();
                    for (int i = 0; i < count; i++) {
                        sb.append(s1);
                    }
                }else sb.append(s);
            }else {
                //表明遇到了之前处理过的字符串，也就是需要进行单字符拼接的片段结束了，现在要进行的是单字符拼接的片段和处理过的字符串进行拼接
                // sb长度为0表明 处理过的字符串之前不存在单字符拼接情况，将sb转换成字符串加入辅助栈stack2，同时也要将处理过的字符串加入辅助栈，并重置sb
                if(sb.length()!=0)stack2.addFirst(sb.reverse().toString());
                stack2.addFirst(s);
                sb=new StringBuilder();
            }
        }

        if(sb.length()!=0){
            stack2.addFirst(sb.reverse().toString());
        }
        //弹出{字符
        stack.removeFirst();
        //将辅助栈的字符串拼接起来，注意此时顺序变为正常顺序了
        StringBuilder sb2=new StringBuilder();
        while(!stack2.isEmpty()){
            sb2.append(stack2.removeFirst());
        }
        //调用getStr方法时}后跟的数字也要重复处理下
        StringBuilder sb3=new StringBuilder();
        for (int i = 0; i < num; i++) {
            sb3.append(sb2.toString());
        }
        //最后将该{}内的字符串重新入栈
        stack.addFirst(sb3.toString());
    }
}