如何处理加括号的四则混合运算表达式——基于二叉树的实现（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)";
       TreeNode lastRoot = null;
       lastRoot = buildTree(str);
       System.out.println("原表达式为:  " + str);
       System.out.print("后续遍历的结果为:  ");
       postOrder(root);
    }

}

运行结果如下：