如何处理加括号的四则混合运算表达式——基于二叉树的实现（Eclipse平台 Java版）

  记得上《数据结构》课程时，利用栈的特性解决过四则混合运算表达式。而如今在编写小型关系数据库的时候，编译部分要处理where后面的逻辑表达式——检查语法正确与否的同时，还要将信息传给下一个接口，进行优化处理，所以存成一棵树的形式是最合理和最方便后续操作的。想到和四则混合运算表达式的处理本质上就是一样的，只是细节方面要考虑更多，要多很多。~

    而编写处理加括号的四则混合运算表达式生成一棵二叉树的程序，完全就是为了先从简单例程中熟悉下思路，再着手where语句的处理。

    首先需要声明的是：因为只是为了熟悉思路，所以为了处理方便，取了点巧——表达式中的数值部分只采用一位整数，还有只是考虑到括号不匹配的出错情况，其它类似出现不合法符号的错误情况都没有在程序中处理。~目标就是建立一棵二叉树，后序遍历后能够正确按照优先级解析出。

    建立二叉树的思路大体如下：

    对于没有错误符号的表达式，从最有右端进行扫描，扫描到的字符无非就是：数字、+、-、*、/、（、）。扫描的目的就是找出表达式最后进行的运算，最后操作的运算符可以存为一个节点，而该运算符把表达式分成左右两部分，即为左右子树。如何循环递归下去，会生成一棵二叉树——其中所有叶子节点中存数字，非叶子节点存的是运算符。到这里，你可能会问下面两个问题：1、怎么判断出最后操作的运算符；2、“博主不打算处理括号了吗？”。下面就开始解析这两个问题。

    1、怎么判断出最后操作的运算符

    如果一个表达式中不存在括号，我想，你是能很容易判断出来最后操作的运算符的。“先乘除后加减嘛。”没错！从最右端扫描表达式，最先扫描到的+/-，必然就是最后操作的表达式，倘若没有+/-，自然就是最先扫描到的*/\为最后操作的运算符。那如果有括号存在呢？先乘除后加减的法则还是成立的。只是要注意，我们可以把情况分得更细一点点——括号内的加减乘除运算符，非括号内的加减乘除运算符。而且，括号内的必先于括号外的操作。所以，寻找到最后操作的运算符情况是这样的：非括号内的+/-、非括号内的*/\、括号内的+/-、括号内的*/\。

    接下来就是代码部分。如果你阅读代码，你会发现这么一个思路：所谓括号内的部分，当“去掉”括号后，处理起来就是普通的表达式。“去掉括号”不要误以为是在原来的式子上直接去掉，那还不改变优先级呀！~以1+(2+3+9*(3-1)+8/(4-2))*5+8*(4-3)的表达式为例，在递归过程出现：

    1+(2+3+9*(3-1)+8/(4-2))*5——> 1

                                                  ——> (2+3+9*(3-1)+8/(4-2))*5 ——> (2+3+9*(3-1)+8/(4-2)) 这个式子中就可以将多余的括号去                                                                                                                                          
  掉，就变成之前处理过的式子了

                                                                                                     ——> 5

                                                                                                                 。。。。。。

     8*(4-3) ——> 8

                  ——> (4-3)处理成4-3——> 4

                                                 ——> 3

    还要提醒一点就是：匹配左右括号和判断算术符是否出现在括号中，可以利用栈。从右向左扫描，碰到")"入栈，碰到一个"("，将一个“)”出栈。如果碰到“(”，却发现栈中没有对应的“)”，说明括号不匹配。而某一运算符只有出现时，栈中没有“)”，说明该运算符出现在括号外。

    以下为代码部分：

import java.io.PrintWriter;

import org.omg.CORBA.DATA_CONVERSION;

class TreeNode{
char data;
TreeNode left;
TreeNode right;
public TreeNode(){
left = null;
right = null;
}
public TreeNode(char newdata) {
data = newdata;
left = null;
right = null;
}
}

public class BinaryTree {

static TreeNode root = null;

static boolean hasOper(String checkOper){
if(checkOper.indexOf("+") == -1&&checkOper.indexOf("-") == -1
&&checkOper.indexOf("*") == -1&&checkOper.indexOf("/") == -1){
return false;
}
else{
return true;
}
}

static TreeNode buildTree(String expression){
/*
* 去除表达式首部和尾部的多余括号
* 当出现了括号不匹配时出现异常 抛出
*/
if(expression.indexOf("(") == 0){
for(int i = 0;i < expression.length();i++){
if(expression.startsWith("(") == true){
if(expression.endsWith(")") == true){
expression = expression.substring(1,expression.length() - 1);
}
else{
/*
* 抛出异常 括号不比配
*/
}

}
}
}
char[] expre = expression.toCharArray();

TreeNode newNode = new TreeNode();
String leftString = new String();
String rightString = new String();
String stack = new String(); //用于存储括号的栈 当表达式检测完毕后 若栈不为空 这说明括号使用不合法
if(hasOper(expression) == true){
int index = 0; //记录最先扫描到的不在括号中的加号或减号 必为表达式运算的最后一次操作
int multi_div = 0; //记录最先扫描到的不在括号中的乘号或除号的位置 只有在扫描不到加号和减号的前提下才有用
for(int i = expre.length -1;i>=0;i--){
if(expre[i] == ')'){
stack = stack + expre[i];
}
else if(expre[i] == '('){
if(stack.length() > 0){
stack = stack.substring(0, stack.length() - 1);
}
}
else if(expre[i] == '+'&&stack.length() == 0||expre[i] == '-'&&stack.length() == 0){
index = i;
break;
}
else if(expre[i] == '/'&&stack.length() == 0||expre[i] == '*'&&stack.length() == 0){
multi_div = i;
}
else{
if(expre[i] < 48||expre[i]>57){
/*
* 抛出异常 出现不合法的字符
*/
}
}
}
if(stack.length() != 0){
/*
* 抛出异常 括号不匹配
*/
}
int separator;
if(index != 0){ //说明表达式的最后运算的为加法或减法
separator = index;
}
else{
separator = multi_div;
}
newNode.data = expre[separator];
int pos = 0;
for(;pos < separator;pos++){
leftString = leftString + expre[pos];
}
pos++;
for(;pos < expre.length;pos++){
rightString = rightString + expre[pos];
}
if(root == null){
root = newNode;
}
newNode.left = buildTree(leftString);
newNode.right = buildTree(rightString);
}
else{
char[] temp = expression.toCharArray();
if(temp.length !=1){
/*
* 抛出异常
*/
}
else{
newNode.data = temp[0];
}
}
return newNode;
}

static void postOrder(TreeNode currNode){
if(currNode != null){
postOrder(currNode.left);
System.out.print(currNode.data);
postOrder(currNode.right);

}
}

public static void main(String[] args) {
// TODO Auto-generated method stub
//String str = "1+(2+3+9*(3-1)+8/(4-2))*5+8+4*3";
String str = "1+(2+3+9*(3-1)+8/(4-2))*5+8*(4-3)";
TreeNode lastRoot = null;
lastRoot = buildTree(str);
System.out.println("原表达式为: " + str);
System.out.print("后续遍历的结果为: ");
postOrder(root);
}

}
运行结果：