LeetCode（394 字符串解码）

如题
有两种思路，一种是从外层向内层拼接

public static String decodeString(String s) {
		if(s.length()==0) {
			return "";
		}
		return write(new StringBuilder(""),s);
    }
	
	public static String write(StringBuilder sb,String s) {
		boolean flag =true;//包含标志
		int bf = 0;//当前数字起点
		int count =0;//包含层数
		boolean numflag = true;//检索数字标志
		for(int i=0;i<s.length();i++) {
			if(s.charAt(i)<='9'&&s.charAt(i)>='0'&&numflag) {//第一次检索数字
				if(i!=bf) {//前面存在非字符数字
					sb.append(s.substring(bf,i));
					bf=i;
				}
				numflag=false;
			}
			if(s.charAt(i)=='[') {//第一次检索到[
				String sl=s.substring(bf, i);//当前数字
				for(int n=i+1;n<s.length();n++) {					
					if(s.charAt(n)==']') {
						if(count==0) {//当前对应的]
							String sr=s.substring(i+1, n);//当前整体字符串包含[]
							for(int m=0;m<Integer.parseInt(sl);m++) {
								sb.append(sr);
							}
							i=n;
							bf=n+1;
							numflag=true;
							break;
						}else {//内层]
							count--;
						}
					}else if(s.charAt(n)=='[') {//存在内层[]
						flag=false;
						count++;
					}
				}			
			}
		}
		if(s.charAt(s.length()-1)!=']') {//对应以字符串结尾
			sb.append(s.substring(s.lastIndexOf(']')+1));
		}
		//不存在内层[]直接返回否则递归调用
		return flag?sb.toString():write(new StringBuilder(""),sb.toString());
	}

对于2[b3[c]]这种就是先拆分为b3[c]b[3c],

另一种思路就是从内层向外层拼接，同样递归实现

public static String decodeString1(String s) {
		if(s.length()==0) {
			return "";
		}
        return write1(new StringBuilder(""),s);
	}

	private static String write1(StringBuilder sb, String s) {
		boolean numflag = true;//数字检索标志
		boolean flag=true;//包含标志
		int count=0;//包含层数
		int bf = 0;//数字起点
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) <= '9' && s.charAt(i) >= '0' && numflag) {// 第一次检索到数字
				if (i != bf) {// 前面存在字符
					sb.append(s.substring(bf, i));
					bf = i;
				}				
				numflag = false;
			}
			if (s.charAt(i) == '[') {// 第一次检索到				
				String sl = s.substring(bf,i);
				for(int n=i+1;n<s.length();n++) {
					if(s.charAt(n)=='[') {//存在内层
						flag=false;
						count++;
					}
					if(s.charAt(n)==']') {
						if(count==0) {//匹配到到当层]
							String sr = s.substring(i+1,n);
							//不存在内层直接拼接否则递归调用返回内层拼接好的
							String rsr=flag?sr:write1(new StringBuilder(""), sr);
							for(int m=0;m<Integer.parseInt(sl);m++) {
								sb.append(rsr);
							}
							i=n;
							bf=n+1;
							numflag=true;
							flag=true;
						}else {![在这里插入图片描述](https://img-blog.csdnimg.cn/20200528170611587.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIzMTM0MDM5,size_16,color_FFFFFF,t_70)
							count--;
						}
					}
				}
			}
		}
		if (s.charAt(s.length() - 1) != ']') {// 对应以字符结尾
			sb.append(s.substring(s.lastIndexOf(']') + 1));
		}
		return sb.toString();
	}

同样的2[b3[c]]就是先拆分为2[bccc]了,分析来说，这种递归上层数与上面相同，但是遍历会少很多