算法实例练习记录——缺少左括号的括号补全中序表达式问题（JAVA实现）

 算法练习记录——问题描述：

•  编写一段程序，给定一个缺少左括号的表达式，并打印出，补全括号之后的中序表达式。
•  例如，给定输入：1 + 2 ) * 3 - 4 ) * 5 - 6 ) ) )
•  你的程序应该输出：( ( 1 + 2 ) * ( ( 3 - 4 ) * ( 5 - 6 ) ) )

---

自己的一些感悟： 

1、 题目本身可能没什么难度，重点在于如何思考出栈入栈的方式。一开始我考虑的是单个字符char的获取--->入栈--->出栈--->组成中序表达式，但这样会出现一个问题，就是当表达式复杂之后，无法进行回溯，在表达式的开头追加左括号。

2、后来在网上看了别人的思路，才知道要将 数字符号 和 操作符符号 进行，分别存储入栈，而且最重要的是一定要用 字符串String 这样就可以避免，上面的问题了。因为可以将一个 中序表达式——字符串，当作一个Stack的对象，来进行入栈和出栈操作。

 3、在编程过程中：

• 解决了如何去除 初始字符串 中的 空格字符 问题——直接忽略，不进行入栈操作。

• 解决了 两位以上数字时 将它们作为一个整体进行入栈、出栈的问题——字符串的 contains(string s) 方法。

---

 

 具体的代码分析，都在代码中了。

import java.util.Stack;

/*
 * 编写一段程序，给定一个缺少左括号的表达式，并打印出，补全括号之后的中序表达式。
 * 例如，给定输入：1 + 2 ) * 3 - 4 ) * 5 - 6 ) ) )
 * 你的程序应该输出：( ( 1 + 2 ) * ( ( 3 - 4 ) * ( 5 - 6 ) ) )
 */

//一个Stack实现，三个String字符串辅助完成。
/*
 * 感觉好复杂，大致思路如下：
 * 1、将操作数——0，1，2，3，4，5，6，7，8，9  和  符号——+，-，*，/ ，）  分别存储在两个字符串中，方便进行入栈处理，
 * 2、String one  负责存储 操作数，String operator  负责存储 符号，分别进行入栈（stack）操作，
 * 3、 当入栈（stack）符号里出现 ） 右括号时，进行 中序表达式 的组合——出栈 4个 字符串，
 * 4、然后在最左边添加上 （ 左括号，将组合后的 中序表达式 存储进新的String endstr 中，然后重新入栈（strack）中，最为一个stack对象，
 * 5、重复以上2，3，4步骤，指导整个给定的字符串遍历结束。
 */
/*
 * 举例：给定字符串—— 4-2)/9-8)  求中序表达式结果，stack中的变化情况如下：
 * [4]
 * [4, -]
 * [4, -, 2]
 * [4, -, 2, )]
 * [(4-2)]
 * [(4-2), /]
 * [(4-2), /, 9]
 * [(4-2), /, 9, -]
 * [(4-2), /, 9, -, 8]
 * [(4-2), /, 9, -, 8, )]
 * [(4-2), /, (9-8)]
 * [(4-2)/(9-8)]
 */

public class CompleteParenthesesOne {
	
	//整个程序用到的唯一一个栈
	private Stack<String> stack;
	
	CompleteParenthesesOne(){
		stack=new Stack<String>();
	}

	public String completeParenthesesOne(String str) {
		
		//存储 数字0-9
		String one=new String();
		//存储 +-*/）这些符号
		String operator=new String();
		//存储中序表达式的结果，并进行入栈。
		String endstr=new String();
		//用来匹配 原字符串 第i个位置上，取到的字符 是不是 数字符号。 
		String nums="0123456789";

		for(int i=0; i<str.length(); i++) {
			//去除原字符串中的空格
			if(str.substring(i,i+1).equals(" ")){
				continue;
			}
			
			//判定是不是 数字 字符，是的话就继续取下一个，直到出现 符号 字符。
			//避免 两位 以上的操作数时，中序表达式，组合时出现问题。
			if(nums.contains(str.substring(i,i+1)))
			{
				one=one+str.substring(i, i+1);
				continue;
			}
			else
			{
				if(one!="") {
					stack.push(one);
					//System.out.println(stack.toString());
				}
				operator=str.substring(i,i+1);
				stack.push(operator);
			}
			//System.out.println(stack.toString());
			//开始进行 中序表达式 的组合工作，每4个stack对象为一组，进行出栈组合。
			if(operator.equals(")")) {
				for(int j=0; j<4; j++) {
					endstr=stack.pop()+endstr;
				}
				endstr="("+endstr;
				stack.push(endstr);
				endstr="";
				//System.out.println(stack.toString());
			}
			one="";
		}
		
		while(!stack.isEmpty()) {
			endstr=stack.pop()+endstr;
		}
		return endstr;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CompleteParenthesesOne cpone=new CompleteParenthesesOne();
		
		String str="4-2)/5+2)*6-10))";
		System.out.println(cpone.completeParenthesesOne(str));
		String str1="4-2)/9-8)";
		System.out.println(cpone.completeParenthesesOne(str1));
		
		String str2=" 1 + 2 ) *   3 - 4 ) *  5 - 6 ) ) )";
		System.out.println(cpone.completeParenthesesOne(str2));
	}

}