表达式求值（二叉树方法/C++语言描述）（二）

　　表达式二叉树节点的数据可能是运算数或运算符，可以使用一个联合体进行存储；同时还需要一个变量来指示存储的是运算数还是运算符，可以采用和栈方法求值中一样的枚举类型TokenType：

 typedef enum
 {
     BEGIN,
     NUMBER,
     OPERATOR,
     LEFT_BRAC,
     RIGHT_BRAC
 } TokenType;

 class Token
 {
 public:
     TokenType _type;
     union
     {
         char op;
         double num;
     } _data;
 };

　　二叉树方法求值的Calculator类公有继承自节点数据数据类型为Token类的BinaryTree类：

 class Calculator : public BinaryTree<Token>
 {
 public:
     void parseExpression(string expression) throw(string);
     double calculate();

 private:
     stack<char> _stkOperators;
     stack<BinaryTreeNode<Token> *> _stkNodes;
     stack<double> _stkNumbers;

     static int priority(char op);
     static double calculate(double d1, char op, double d2) throw(string);

     void postOrder(BinaryTreeNode<Token> * node);
     void calculateStack() throw(string);
     void dealWithNumber(char *&pToken) throw(string);
     void dealWithOperator(char *&pToken) throw(string);
     void dealWithLeftBrac(char *&pToken) throw(string);
     void dealWithRightBrac(char *&pToken) throw(string);
 };

方法parseExpression()用来将表达式转换为二叉树，它需要两个栈，一个用来存储运算符，一个用来存储指向子树的指针；用来存储浮点类型的栈仅在求值时使用。由于parseExpression方法需要访问BinaryTreeNode类的私有成员，因此还要在BinaryTreeNode类中声明Calculator类为友元类。

　　转换过程与栈方法求值的运算压栈过程基本相同，当遇到运算数时，生成一个新的节点并将它的指针压入节点指针栈中；遇到运算符时比较当前运算符和运算符栈栈顶运算符的优先级，若运算符栈栈顶运算符的优先级较高，则为它生成一个新的节点，并从节点指针栈中弹出两个节点指针，作为新节点的左子树和右子树，随后将这个新节点的指针压入节点指针栈中，将当前运算符压入运算符栈中，否则只将当前运算符压入运算符栈中。最后反复执行上述过程，直至运算符栈为空，节点指针栈的栈顶元素即为指向树根节点的指针。表达式“1+2*3”和“1*2+3”的转换过程如下图：

使用代码描述操作节点指针栈的过程：

 void Calculator::calculateStack() throw(string)
 {
     BinaryTreeNode<Token> * node = new BinaryTreeNode<Token>();
     assert(node);
     node->_data._type = OPERATOR;
     node->_data._data.op = _stkOperators.top();
     _stkOperators.pop();
     assert(!_stkNodes.empty());
     node->_rightChild = _stkNodes.top();
     _stkNodes.pop();
     assert(!_stkNodes.empty());
     node->_leftChild = _stkNodes.top();
     _stkNodes.pop();
     _stkNodes.push(node);
 }

　　根据数学规则以及最后清空运算符栈的过程，parseExpression()方法实现如下：

 void Calculator::parseExpression(string expression) throw(string)
 {
     destory();
     while (!_stkNodes.empty())
     {
         _stkNodes.pop();
     }
     while (!_stkOperators.empty())
     {
         _stkOperators.pop();
     }
     TokenType lastToken = BEGIN;

     char * pToken = &expression[];
     while (*pToken)
     {
         switch (lastToken)
         {
         case BEGIN:
             if (*pToken == '(')
             {
                 // an expression begin with a left bracket
                 dealWithLeftBrac(pToken);;
                 lastToken = LEFT_BRAC;
             }
             else
             {
                 // or a number
                 dealWithNumber(pToken);
                 lastToken = NUMBER;
             }
             break;
         case NUMBER:
             // after a number
             if (*pToken == ')')
             {
                 // it may be a right bracket
                 dealWithRightBrac(pToken);
                 lastToken = RIGHT_BRAC;
             }
             else
             {
                 // it may be an operator
                 dealWithOperator(pToken);
                 lastToken = OPERATOR;
             }
             break;
         case OPERATOR:
         case LEFT_BRAC:
             // after an operator or a left bracket
             if (*pToken == '(')
             {
                 // it may be a left bracket
                 dealWithLeftBrac(pToken);
                 lastToken = LEFT_BRAC;
             }
             else
             {
                 // it may be a number
                 dealWithNumber(pToken);
                 lastToken = NUMBER;
             }
             break;
         case RIGHT_BRAC:
             // after a right bracket
             if (*pToken == ')')
             {
                 // it may be another right bracket
                 dealWithRightBrac(pToken);
                 lastToken = RIGHT_BRAC;
             }
             else
             {
                 // it may be an perator
                 dealWithOperator(pToken);
                 lastToken = OPERATOR;
             }
             break;
         }
     }

     while (!_stkOperators.empty())
     {
         if (_stkOperators.top() == '(')
         {
             throw string("bad token '('");
         }
         calculateStack();
     }

     assert(!_stkNodes.empty());
     _root = _stkNodes.top();
 }

方法实现与栈方法求值的公有方法calculator()基本相同。开始调用的destory()方法继承自BinaryTree类，用于释放已占用的二叉树节点空间，可以防止程序内存溢出。