Expression Tree

1. /**
2.  * filename: ExpressionTree.java
3.  * package: 
4.  * author: Nick Ma
5.  * email: nick.ma85@yahoo.com
6.  * date: Nov 1, 2008
7.  * description: this class implements an expression tree extended from binary tree.
8.  */
10. import  java.util.*;
12. public   class  ExpressionTree  extends  BinaryTree {
14.          // Data Field
15.         
16.          /** the operators */
17.          private   static   final  String OPERATORS =  "+-*/" ;
18.         
19.          /** the original infix expression */
20.          private  String originalExp;
22.          /**
23.          * description: the constructor with fields to build an expression tree from infix
24.          * @param originalExp - infix exp
25.          */
26.          public  ExpressionTree(String originalExp) {
27.                  this .originalExp = originalExp;
28.                 
29.                 InfixToPostfixConvertor pc =  new  InfixToPostfixConvertor();
30.                  try  {
31.                          // convert the original infix exp to postfix
32.                         StringTokenizer st =  new  StringTokenizer(pc.convert(originalExp));
33.                          // stack to save temp tree nodes
34.                         Stack<TreeNode> treeStack =  new  Stack<TreeNode>();
35.                         
36.                          while (st.hasMoreTokens()) {
37.                                  // iterator the tokens
38.                                 String nextToken = st.nextToken();
39.                                  char  firstChar = nextToken.charAt( 0 );
40.                                  // determine if it is an operand
41.                                  if (Character.isJavaIdentifierStart(firstChar)
42.                                                 || Character.isDigit(firstChar)){
43.                                         treeStack.push( new  TreeNode(nextToken));
44.                                 }  else   if (isOperator(firstChar)) {
45.                                          // pop two operands
46.                                         TreeNode right = treeStack.pop();
47.                                         TreeNode left = treeStack.pop();
48.                                         
49.                                          //create a new tree to push
50.                                         treeStack.push( new  TreeNode(nextToken, left, right));
51.                                 }  else  {
52.                                          throw   new  SyntaxErrorException( "syntax error!" );
53.                                 }
54.                         }
55.                         
56.                          // determine if the tree stack just has one tree
57.                          if (treeStack.size() !=  1 ) {
58.                                  throw   new  SyntaxErrorException( "syntax error" );
59.                         }
60.                         
61.                          // let the only tree node popped from the tree stack be the root
62.                          this .root = treeStack.pop();
63.                         
64.                          // determine if the tree stack is empty
65.                          if (!treeStack.isEmpty()) {
66.                                  throw   new  SyntaxErrorException( "syntax error" );
67.                         }
68.                 }  catch (Exception e) {
69.                         e.printStackTrace();
70.                 }
71.         }
72.         
73.          /**
74.          * description: print prefix exp from this tree
75.          */
76.          public   void  prefix(TreeNode node) {
77.                  if (node ==  null ) {
78.                          return ;
79.                 }  else  {
80.                         System.out.print((String)node.getData());
81.                         prefix(node.getLeft());
82.                         prefix(node.getRight());
83.                 }
84.         }
85.         
86.          /**
87.          * description: print infix exp from this tree
88.          */
89.          public   void  infix(TreeNode node) {
90.                  if (node ==  null ) {
91.                          return ;
92.                 }  else  {
93.                          if (!Character.isJavaIdentifierStart(((String)node.getData()).charAt( 0 ))) {
94.                                 System.out.print( "(" );
95.                         }
96.                         
97.                         infix(node.getLeft());
98.                         System.out.print((String)node.getData());
99.                         infix(node.getRight());
100.                         
101.                          if (!Character.isJavaIdentifierStart(((String)node.getData()).charAt( 0 ))) {
102.                                 System.out.print( ")" );
103.                         }
104.                 }
105.         }
106.         
107.          /**
108.          * description: print postfix exp from this tree
109.          */
110.          public   void  postfix(TreeNode node) {
111.                  if (node ==  null ) {
112.                          return ;
113.                 }  else  {
114.                         postfix(node.getLeft());
115.                         postfix(node.getRight());
116.                         System.out.print((String)node.getData());
117.                 }
118.         }
119.         
120.          /**
121.          * description: evaluate the expression tree
122.          * @return - the value of the expression
123.          */
124.          public   int  evaluate() {
125.                 InfixToPostfixConvertor pc =  new  InfixToPostfixConvertor();
126.                 StringBuilder sb =  new  StringBuilder();
127.                 Random rd =  new  Random();
128.                 String postfix =  null ;
129.                  try  {
130.                          // convert the original infix exp to postfix
131.                         postfix = pc.convert( this .originalExp);
132.                         
133.                          // build a postfix expression string
134.                         StringTokenizer st =  new  StringTokenizer(postfix);
135.                          while (st.hasMoreTokens()) {
136.                                 String next = st.nextToken();
137.                                  if (Character.isJavaIdentifierStart(next.charAt( 0 ))) {
138.                                          // generate the integer random for the variables of this expression
139.                                         sb.append(rd.nextInt( 100 ));
140.                                 }  else  {
141.                                         sb.append(next);
142.                                 }
143.                                 sb.append( " " );
144.                         }
145.                         
146.                         System.out.print(sb.toString() +  " = " );
147.                         
148.                          // call postfix evaluator
149.                         PostfixEvaluator pe =  new  PostfixEvaluator(sb.toString());
150.                          return  pe.eval();
151.                         
152.                 }  catch (Exception e) {
153.                         e.printStackTrace();
154.                          return   0 ;
155.                 }
156.         }
157.         
158.          /**
159.          * description: determine whether a char is an operator
160.          * @param op - the given char
161.          * @return - true if the char is an operator
162.          */
163.          private   boolean  isOperator( char  op) {
164.                  return  OPERATORS.indexOf(op) != - 1 ;
165.         }
167.          /**
168.          * @return the root
169.          */
170.          public  TreeNode getRoot() {
171.                  return  root;
172.         }
174.          /**
175.          * @param root the root to set
176.          */
177.          public   void  setRoot(TreeNode root) {
178.                  this .root = root;
179.         }
180. }