二叉树计算四则运算表达式

转自：http://blog.csdn.net/a477997/article/details/7369151

1 * 2 / ( ( 3 + 4 ) * ( - 5 + 6 ) )

这样一个式子，采用二叉树实现四则运算，需要使用递归的思想。总共分两步，第一步是建立二叉树，第二步是计算。

建立二叉树：

将式子存入一个char[] expresstion中，然后带入一个消除多余括号的函数TrimOutParenthes（消除括号，例如(1 * 2 / ( ( 3 + 4 ) * ( - 5+ 6 ) ))的最外层括号，主要用于消除分支节点中的括号，例如( 3 + 4 )），然后从右向左扫描每一个元素，找到最外层（括号外的）中最左边的符号，将该符号（例如式子中的*）作为父节点，将符号两边的式子作为子节点。如下：

*

1            2/ ( ( 3 + 4 ) * ( - 5 + 6 ) )

然后递归计算这两个子节点，也就是作为表达式再次代入。

2 / ( ( 3 + 4 ) * ( - 5 + 6 ) )的计算结果是：

/

2            (( 3 + 4 ) * ( - 5 + 6 ) )

于是目前的结果就是

                            *

              1                          /

                                   2            ( 3 + 4 ) * ( - 5 + 6 )

以此类推，得到整棵二插运算树。

package com.zeph.calculator;

public class Calculator {

	/**
	 * @param args
	 * @author JiangQifan
	 * @since 2012/3/19
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Calculator ca = new Calculator();
		ca.calculator();

	}

	public void calculator() {
		double a = new TreeNode("1+2+(3+4)+5+6").calculate();
		System.out.println(a);

	}

	class TreeNode {

		double data;
		char operation;
		TreeNode left;
		TreeNode right;

		/*
		 * recursively construct the tree
		 */
		public TreeNode(String expression) {
			char[] exc = toCharArrayTrimOutParenthes(expression);
			if (exc == null) {
				return;
			}
			exc = syntaxCheck(exc);
			int length = exc.length;

			int index = 0;

			if (hasOperation(exc)) {
				int parenthes = 0;

				for (int i = length - 1; i >= 0; i--) {

					if (exc[i] == '(') {
						parenthes--;
					} else if (exc[i] == ')') {
						parenthes++;
					}

					if (parenthes > 0) {
						continue;
					}

					if (exc[i] == '*' || exc[i] == '/') {
						index = i;
					} else if (exc[i] == '+' || exc[i] == '-') {
						index = i;
						break;
					}

				}
				if (isOperation(exc[index])) {
					operation = exc[index];
				}
				StringBuilder sbleft = new StringBuilder();
				StringBuilder sbright = new StringBuilder();

				for (int i = 0; i < index; i++) {
					sbleft.append(exc[i]);
				}
				for (int i = index + 1; i < length; i++) {
					sbright.append(exc[i]);
				}
				left = new TreeNode(sbleft.toString());
				right = new TreeNode(sbright.toString());

			} else {
				StringBuilder value = new StringBuilder();
				value.append(exc);
				data = Double.parseDouble(value.toString());
			}
		}

		/*
		 * check the expression's syntax if there is two or more continuous
		 * operations,print out syntax error add '0' before the '-' if it's a
		 * negative
		 */
		public char[] syntaxCheck(char[] cArray) {
			boolean flag = false;
			if (isOperation(cArray[0])) {
				char[] checkedArray = new char[cArray.length + 1];
				checkedArray[0] = '0';
				for (int i = 0; i < cArray.length; i++) {
					checkedArray[i + 1] = cArray[i];
				}
				cArray = checkedArray;
			}
			for (int i = 0; i < cArray.length; i++) {
				if (isOperation(cArray[i])) {
					if (flag == true) {
						System.out.println("syntaxError");
					}
					flag = true;
				} else {
					flag = false;
				}
			}

			return cArray;
		}

		/*
		 * is there operations in the char array if there is,return true. if
		 * not,return false
		 */
		public boolean hasOperation(char[] cArray) {
			for (int i = 0; i < cArray.length; i++) {
				if (isOperation(cArray[i])) {
					return true;
				}

			}
			return false;
		}

		public boolean isOperation(char c) {
			return (c == '+' || c == '-' || c == '*' || c == '/');

		}

		/*
		 * trim the out most useless parentheses and return a char array
		 */
		public char[] toCharArrayTrimOutParenthes(String src) {

			if (src.length() == 0) {
				return null;
			}
			String result = src;
			while (result.charAt(0) == '('
					&& result.charAt(result.length() - 1) == ')') {
				int parenthes = 0;
				for (int i = 0; i < result.length() - 1; i++) {
					if (result.charAt(i) == '(') {
						parenthes++;
					} else if (result.charAt(i) == ')') {
						parenthes--;
					}
					if (parenthes == 0) {
						return result.toCharArray();
					}
				}
				result = result.substring(1, result.length() - 1);

			}

			return result.toCharArray();
		}

		// recursively calculate
		public double calculate() {
			double result = 0;
			if (left == null && right == null) {
				result = data;
			} else {
				double leftResult = left.calculate();
				double rightResult = right.calculate();
				switch (operation) {
				case '+':
					result = leftResult + rightResult;
					break;
				case '-':
					result = leftResult - rightResult;
					break;
				case '*':
					result = leftResult * rightResult;
					break;
				case '/':
					result = leftResult / rightResult;
					break;
				default:
					break;
				}
			}
			return result;
		}
	}
}