栈的简单应用——四则运算(三)

待解决问题

      如何计算带括号的四则运算？

解决方案

       一、采用符号入栈的解决方式，只是圆括号的操作方式会有所改变。圆括号的优先级最高，"("入栈后，只有遇到")"后才会出栈，并且要先弹出"("后的遗留操作符，保证"( )"中的表达式先被执行。"( )"中的加减乘除操作保持正常的栈处理方式。

      二、采用lisp解决问题的思路。所有的"( )"内的操作都是一样的，只不过处理的层次不一样，这时使用递归是一种很容易理解的方式。将每组"()"中的表达式看成子表达式，用相同的方法处理，将处理的结果拼接到父表达式维护的变量中。这种方式没有改变括号先行的原则。

代码实现

      我采用了第二种解决方案。

• 符号优先级的初始化     

private  static Map<String,Integer> priorityMap = new HashMap<String,Integer>();
	private  static String symPattern = "";
	private Stack<String> stack = new Stack<String>();
	static{
		symPattern = "[+\\-*/]";
		priorityMap.put("+", -1);
		priorityMap.put("-", -1);
		priorityMap.put("*", 1);
		priorityMap.put("/", 1);
	}

• 标准表达式输入

public String input(){
		Scanner scanner = new Scanner(System.in);
		String str = "";
		if(scanner.hasNext()){
			str += scanner.next();
		}
		System.out.println("the value of str = " + str);
		return str;
	}

• 校验输入的表达式是否合法

public boolean checkInput(String input) throws Exception{
		char[] array = input.toCharArray();
		for(int i=0;i<array.length;i++){
			if(i<array.length - 1){
				String prev = String.valueOf(array[i]);
				String next = String.valueOf(array[i+1]);
				if(!prev.matches("[\\(\\)\\d\\.+\\-*/]")||!next.matches("[\\(\\)\\d\\.+\\-*/]")){
					throw new Exception("输入中含有非法字符，请重新输入！" );
				}else if(prev.matches("[\\.+\\-*/]")&&next.matches("[\\.+\\-*/]")){
					throw new Exception("输入了连续的符号！请重新输入！");
				}else if(prev.matches("/")&&next.matches("0")){
					throw new Exception("分母不能为零！");
				}
			}else{
				if(!String.valueOf(array[i]).matches("\\d")){
					throw new Exception("非法表达式");
				}
			}
		}
		return true;
	}

• 将中缀表达式转换为后缀表达式

public String generateSuffixExp(String input) throws Exception{
		Stack<String> stack = new Stack<String>();
		char[] array = input.toCharArray();
		String suffix = "";
		int matchIndex = 0;
		for(int i = 0;i < array.length;i++){
			String atom = String.valueOf(array[i]);
			//括号先行，取得括号中的子表达式并获取其后缀表达式
			if(atom.equals("(")){
				//获取与左括号正确匹配的右括号索引
				matchIndex = this.matchIndex(input,i);
				//获取该组括号的中的子表达式
				String innerExp = input.substring(i+1, matchIndex);
				//获取子表达式的后缀表达式
				atom = generateSuffixExp(innerExp);
				i = matchIndex;
			}
			if(atom.matches(symPattern)){
				if(stack.isEmpty()){
					stack.push(atom);
				}else{
					
					while(!stack.isEmpty()&&priorityMap.get(stack.peek()) >= priorityMap.get(atom)){
						suffix += stack.pop();
					}
					
					stack.push(atom);
				}
			}else{
				while((i+1 < array.length)&&!(String.valueOf(array[i+1])).matches(symPattern)){
					atom += array[++i];
				}
				//atom是十以外的数字或非某组括号中的子表达式，将atom用原括号包装成一个整体
				if(atom.length() != 1&&!String.valueOf(atom.charAt(atom.length()-1)).matches(symPattern)){
					atom = "(" + atom +")";
				}
				suffix +=atom;
			}
		}
		while(!stack.isEmpty()){
			suffix += stack.pop();
		}
		return suffix;
	}
	public int matchIndex(String exp,int start) throws Exception{
		int count = 0;
		for(int i = start;i < exp.length();i++){
			char atom = exp.charAt(i);
			if(atom == '('){
				count++;
			}else if(atom == ')'){
				count--;
				if(count == 0){
					return i;
				}
			}
		}
		throw new Exception("wrong expression!");
	}

• 计算后缀表达式

public String resuleCompute(String suffix){
		String result = "";
		for(int i=0;i<suffix.length();i++){
			String atom = String.valueOf(suffix.charAt(i));
			if(atom.matches("\\d")){
				stack.push(atom);
			}else if(atom.matches("\\(")){
				atom = "";
				while(!String.valueOf(suffix.charAt(++i)).equals(")")){
					atom += String.valueOf(suffix.charAt(i));
				}
				stack.push(atom);
			}else{
				float a = Float.parseFloat(stack.pop());
				float b = Float.parseFloat(stack.pop());
				float resultExp = this.getMiddleResult(a, b, atom);
				stack.push(""+resultExp);
			}
		}
		result = stack.pop();
		stack.clear();
		return result;
	}
	public float getMiddleResult(float a,float b,String symbol){
		if("+".equals(symbol)){
			return b + a;
		}else if("-".equals(symbol)){
			return b - a;
		}else if("*".equals(symbol)){
			return b * a;
		}else{
			return b / a;
		}
	}

• 执行程序

public static void main(String[] args) throws Exception{
		Cal_Version_3 cal = new Cal_Version_3();
		while(true){
			String input = cal.input();
			if(cal.checkInput(input)){
				String suffix = cal.generateSuffixExp(input);
				System.out.println("the value of suffix is " + suffix);
				System.out.println(cal.resuleCompute(suffix));
			}
		}
	}

• 执行结果

9+(3-1)*3+10/2
the value of str = 9+(3-1)*3+10/2
the value of suffix is 931-3*+(10)2/+
20.0

2.5+(2*(2.5+2))+2.5
the value of str = 2.5+(2*(2.5+2))+2.5
the value of suffix is (2.5)2(2.5)2+*+(2.5)+
14.0

结果讨论

     程序达到了预期的效果，但是还有很多工作要做，但基本目的已经达到了，已经了解了java实现表达式的四则运算。