表达式求值Java粗糙版

表达式求值Java粗糙版

/**
 * 
  */
package  com.yovn.algo;

import  java.util.Stack;
import  java.util.Vector;

/**
 *  @author  yovn
 *
  */
public   class  Caculator {

    
     class  Item
    {
         boolean  ops;
         int  value;
        
        Character opVal;
         int  opPriority;
    }
    
    Stack < Item >  opStack = new  Stack < Item > ();
    Vector < Item >  calcStack = new  Vector < Item > ();
     /**
     * 
      */
     public  Caculator() {
         //  TODO Auto-generated constructor stub
    }
    
    
    
    
     public   int  calc()
    {
        Stack < Item >  tmp = new  Stack < Item > ();
         while ( ! calcStack.isEmpty())
        {
            Item it = calcStack.remove( 0 );
            
             if ( ! it.ops)
            {
                tmp.push(it);
            }
             else
            {
                 int  op2 = tmp.pop().value;
                 int  op1 = tmp.pop().value;
                Item newItem = new  Item();
                newItem.ops = true ;
                 switch (it.opVal)
                {
                 case   ' + ' :
                    newItem.value = op1 + op2;
                    
                     break ;
                 case   ' - ' :
                    newItem.value = op1 - op2;
                     break ;
                 case   ' * ' :
                    
                    newItem.value = op1 * op2;
                     break ;
                 case   ' / ' :
                    newItem.value = op1 / op2;
                     break ;
                }
                tmp.push(newItem);
            }
        }
         return  tmp.pop().value;
    }
     /**
     * 1)数字直接输出
     * 2)开括号则压栈
     * 3）闭括号把栈中元素依次输出直到遇到开括号
     * 4）运算符时
     *     a)循环，当栈非空，并且栈顶元素不是开括号，并且栈顶运算符优先级不低于输入的运算符的优先级，反复将其输出
     *     b）把输入运算符压栈
     * 5）输出栈内剩余元素
     *  @param  in
     *  @return
      */
     public  String transInfixToPosfix(String in)
    {
         char [] cin = in.toCharArray();
        StringBuffer buffer = new  StringBuffer();
       
         for ( int  i = 0 ;i < cin.length;i ++ )
        {
            Item newItem = new  Item();
            newItem.opPriority = 1 ;
            newItem.ops = false ;
            
             switch (cin[i])
            {
            
             case   ' + ' :
                newItem.opPriority = 1 ;
                newItem.ops = true ;
                newItem.opVal = ' + ' ;
                doOps(buffer, newItem);
                
                 break ;
             case   ' - ' :
                newItem.opPriority = 1 ;
                newItem.ops = true ;
                newItem.opVal = ' - ' ;
                doOps(buffer, newItem);
                 break ;
             case   ' * ' :
                newItem.opPriority = 2 ;
                newItem.ops = true ;
                newItem.opVal = ' * ' ;
                doOps(buffer, newItem);
                 break ;
             case   ' / ' :
                newItem.opPriority = 2 ;
                newItem.ops = true ;
                newItem.opVal = ' / ' ;
                doOps(buffer, newItem);
                 break ;
                
             case   ' ( ' :
                newItem.ops = true ;
                newItem.opVal = ' ( ' ;
                opStack.push(newItem);
                
                 break ;
             case   ' ) ' :
                 boolean  meetClose = false ;
                 while ( ! opStack.isEmpty())
                {
                    Item item = opStack.peek();
                     if (item.ops && item.opVal != ' ( ' )
                    {
                        calcStack.add(item);
                        opStack.pop();
                        buffer.append(item.opVal);
                    }
                     else   if (item.ops)
                    {
                        opStack.pop();
                        meetClose = true ;
                         break ;
                    }
                }
                 if ( ! meetClose)
                {
                     throw   new  RuntimeException();
                }
                 break ;
                
             default :
                 int  j = i;
                 for (;j < cin.length && cin[j] >= ' 0 ' && cin[j] <= ' 9 ' ;j ++ );
                 if (j == i)
                {
                     throw   new  RuntimeException( " wrong input. " );
                }
                newItem.ops = false ;
                newItem.value = Integer.parseInt( new  String(cin,i,j - i));
                buffer.append(newItem.value);
                calcStack.add(newItem);
                i = j - 1 ;
                 break ;
                
                
            }
        }
         while ( ! opStack.isEmpty())
        {
            Item item = opStack.pop();
            calcStack.add(item);
            buffer.append(item.opVal);
            
        }
         return  buffer.toString();
        
    }



     private   void  doOps(StringBuffer buffer, Item newItem) {
         while ( ! opStack.isEmpty())
        {
            Item item = opStack.peek();
             if (item.opVal != ' ( ' && item.opPriority >= newItem.opPriority)
            {
                calcStack.add(item);
                opStack.pop();
                buffer.append(item.opVal);
            }
             else
            {
                 break ;
            }
        }
        opStack.push(newItem);
    }
    

     /**
     *  @param  args
      */
     public   static   void  main(String[] args) {
        Caculator calc = new  Caculator();
        
        System.out.println( " 1+2*3+7-(4/2+8)/5= " + calc.transInfixToPosfix( " 1+2*3+7-(4/2+8)/5 " ));
        System.out.println( " value is: " + calc.calc());

    }

}