Infix to Postfix Convertor

1. /**
2.  * filename: InfixToPostfixConvertor.java
3.  * package: 
4.  * author: Nick Ma
5.  * email: [email protected]
6.  * date: Nov 1, 2008
7.  * description: this class implements a string convertor from infix to postfix.
8.  */
10. import  java.util.*;
12. public   class  InfixToPostfixConvertor {
14.          // Data Field
15.         
16.          /** the operator stack */
17.          private  Stack<Character> operatorStack;
18.         
19.          /** the operators */
20.          private   static   final  String OPERATORS =  "+-*/()" ;
21.         
22.          /** the precedence of the operators */
23.          private   static   final   int [] PRECEDENCE = { 1 ,  1 ,  2 ,  2 , - 1 , - 1 };
24.         
25.          /** the postfix string */
26.          private  StringBuilder postfix;
27.         
28.          /**
29.          * description: the default constructor
30.          */
31.          public  InfixToPostfixConvertor() {
32.                  // TODO Auto-generated constructor stub
33.                 
34.                 postfix =  new  StringBuilder();
35.         }
37.          /**
38.          * description: convert a string from infix to postfix
39.          * @param infix - the infix string to input
40.          * @return - the postfix string
41.          * @throws Exception
42.          */
43.          public  String convert(String infix)  throws  Exception {
44.                 operatorStack =  new  Stack<Character>();
45.                 
46.                 StringTokenizer infixTokens =  new  StringTokenizer(infix);
47.                  try  {
48.                          // process each token in the infix string
49.                          while (infixTokens.hasMoreTokens()) {
50.                                 String nextToken = infixTokens.nextToken();
51.                                  char  firstChar = nextToken.charAt( 0 );
52.                                  // determine if it is an operator
53.                                  if (Character.isJavaIdentifierStart(firstChar)
54.                                                 || Character.isDigit(firstChar)){
55.                                         postfix.append(nextToken);
56.                                         postfix.append( ' ' );
57.                                 }  else   if (isOperator(firstChar)) {
58.                                         processOperator(firstChar);
59.                                 }  else  {
60.                                          throw   new  SyntaxErrorException( "syntax error!" );
61.                                 }
62.                         }
63.                         
64.                          // pop any remaining operators and append them to postfix
65.                          while (!operatorStack.isEmpty()) {
66.                                 Character op = operatorStack.pop();
67.                                  // any '(' on the stack is not matched
68.                                  if (op.charValue() ==  '(' ) {
69.                                          throw   new  SyntaxErrorException( "syntax error!" );
70.                                 }
71.                                 postfix.append(op);
72.                                 postfix.append( ' ' );
73.                         }
74.                          return  postfix.toString();
75.                 }  catch (EmptyStackException e) {
76.                          throw   new  SyntaxErrorException( "the stack is empty!" );
77.                 }
78.         }
79.         
80.          /**
81.          * description: process operators
82.          * @param op - the operator
83.          */
84.          private   void  processOperator( char  op) {
85.                  if (operatorStack.isEmpty() || op ==  '(' ) {
86.                         operatorStack.push(op);
87.                 }  else  {
88.                          // peek the operator stack
89.                          char  topOp = operatorStack.peek().charValue();
90.                          if (precedence(op) > precedence(topOp)) {
91.                                 operatorStack.push(op);
92.                         }  else  {
93.                                  // pop all stacked operators with equal or higher precedence than op
94.                                  while (!operatorStack.isEmpty() && precedence(op) <= precedence(topOp)) {
95.                                         operatorStack.pop();
96.                                          if (topOp ==  '(' ) {
97.                                                  break ;
98.                                         }
99.                                         postfix.append(topOp);
100.                                         postfix.append( ' ' );
101.                                          if (!operatorStack.isEmpty()) {
102.                                                  // reset topOp
103.                                                 topOp = operatorStack.peek().charValue();
104.                                         }
105.                                 }
106.                                  if (op !=  ')' ) {
107.                                         operatorStack.push(op);
108.                                 }
109.                         }
110.                 }
111.         }
112.         
113.          /**
114.          * description: determine the precedence of an operator
115.          * @param op - the operator
116.          * @return - the precedence
117.          */
118.          private   int  precedence( char  op) {
119.                  return  PRECEDENCE[OPERATORS.indexOf(op)];
120.         }
121.         
122.          /**
123.          * description: determine whether a char is an operator
124.          * @param op - the given char
125.          * @return - true if the char is an operator
126.          */
127.          private   boolean  isOperator( char  op) {
128.                  return  OPERATORS.indexOf(op) != - 1 ;
129.         }
130.         
131.          // test function
132.          public   static   void  main(String[] args) {
133.                 InfixToPostfixConvertor pc =  new  InfixToPostfixConvertor();
134.                  try  {
135.                         System.out.println(pc.convert( "( x + y ) * ( ( a + b ) / c )" ));
136.                 }  catch (Exception e) {
137.                         e.printStackTrace();
138.                 }       
139.         }
140. }
143. /**
144.  * filename: SyntaxErrorException.java
145.  * package:  
146.  * author:   Li Ma
147.  * email:    [email protected]
148.  * date:     Oct 3, 2008
149.  * description: this exception shows a syntax error.
150.  */
152. public   class  SyntaxErrorException  extends  Exception {
154.          private   static   final   long  serialVersionUID = 1L;
156.          public  SyntaxErrorException( final  String message) {
157.                  super (message);
158.         }
159. }