逆波兰式算法java

表达式运算，网上查了一下java有源代码。不过问题太多。而且都是一个版本。

根本没法使用。

逆波兰式算法主要的设计思路是把一般的中序表达式变为右序表达式

例子1+2-5*(5-4)*6-(6-1)

把上面的表达式转化为：

 12+554-*6*-61--

然后通过栈再来计算。

具体的理论网上找找逆波兰式

根据人家的版本进行了修改。

package  expression1;     
import  java.util. * ;     
// 栈类     
public   class  Stacks ... {     
   private LinkedList list=new LinkedList();     
   int top=-1;     
   public void push(Object value)...{     
      top++;     
      list.addFirst(value);     
   }     
   public Object pop()...{     
      Object temp=list.getFirst();     
      top--;     
      list.removeFirst();     
      return temp;     
   
   }     
   public Object top()...{     
   return list.getFirst();     
   }     
}      

 

 

 

package  expression1;    
   
import  java.io. * ;    
import  java.util. * ;    
   
public   class  Expression  ... {    
    private ArrayList expression = new ArrayList();// 存储中序表达式    
   
    private ArrayList right = new ArrayList();// 存储右序表达式    
   
    private String result;// 结果    
   
    // 依据输入信息创建对象，将数值与操作符放入ArrayList中    
    private Expression(String input) ...{    
        StringTokenizer st = new StringTokenizer(input, "+-*/()", true);    
        while (st.hasMoreElements()) ...{ 
            String s=st.nextToken();
            expression.add(s);
        }
    }
   
    // 将中序表达式转换为右序表达式
    private void toRight() ...{ 
        Stacks aStack = new Stacks();  
        String operator;
        int position = 0;
        while (true) ...{
            if (Calculate.isOperator((String) expression.get(position))) ...{    
                if (aStack.top == -1   
                        || ((String) expression.get(position)).equals("(")) ...{    
                    aStack.push(expression.get(position));    
                } else ...{    
                    if (((String) expression.get(position)).equals(")")) ...{  
                        while(true)...{
                        
                            if (aStack.top != -1&&!((String) aStack.top()).equals("(")) ...{    
                                operator = (String) aStack.pop();
                                right.add(operator);    
                            }else...{
                                if(aStack.top != -1)
                                    aStack.pop();
                                break;
                            }   
                        } 
                    } else ...{  
                        while(true)...{
                            if (aStack.top != -1&&Calculate.priority((String) expression    
                                    .get(position)) <= Calculate    
                                    .priority((String) aStack.top())    
                                    ) ...{    
                                operator = (String) aStack.pop(); 
                                if (!operator.equals("("))    
                                    right.add(operator);    
                            }else...{
                                break;
                            }    
                            
                        } 
                        aStack.push(expression.get(position));
                    }    
                }    
            } else   
                right.add(expression.get(position));    
            position++;    
            if (position >= expression.size())    
                break;    
        }    
        while (aStack.top != -1) ...{    
            operator = (String) aStack.pop();  
            if(!operator.equals("("))  
                right.add(operator);    
        }    
    }    
   
    // 对右序表达式进行求值    
    private void getResult() ...{    
        this.toRight();
        for(int i=0;i<right.size();i++)...{
            System.out.println(right.get(i));  
        }    
        Stacks aStack = new Stacks();    
        String op1, op2, is = null;    
        Iterator it = right.iterator();    
   
        while (it.hasNext()) ...{    
            is = (String) it.next();    
            if (Calculate.isOperator(is)) ...{    
                op1 = (String) aStack.pop();    
                op2 = (String) aStack.pop();    
                aStack.push(Calculate.twoResult(is, op1, op2));    
            } else   
                aStack.push(is);    
        }    
        result = (String) aStack.pop();    
        it = expression.iterator();    
        while (it.hasNext()) ...{    
            System.out.print((String) it.next());    
        }    
        System.out.println("=" + result);    
    }    
   
    public static void main(String avg[]) ...{    
        try ...{    
            System.out.println("Input a expression:");    
            BufferedReader is = new BufferedReader(new InputStreamReader(    
                    System.in));    
            for (;;) ...{    
                String input = new String();    
                input = is.readLine().trim();    
                if (input.equals("q"))    
                    break;    
                else ...{    
                    Expression boya = new Expression(input);    
                    boya.getResult();    
                }    
                System.out    
                        .println("Input another expression or input 'q' to quit:");    
            }    
            is.close();    
        } catch (IOException e) ...{    
            System.out.println("Wrong input!!!");    
        }    
    }    
}     

 

 

ackage expression1;    
   
public   class  Calculate  ... {    
    // 判断是否为操作符号    
    public static boolean isOperator(String operator) ...{    
        if (operator.equals("+") || operator.equals("-")    
                || operator.equals("*") || operator.equals("/")    
                || operator.equals("(") || operator.equals(")"))    
            return true;    
        else   
            return false;    
    }    
   
    // 设置操作符号的优先级别    
    public static int priority(String operator) ...{    
        if (operator.equals("+") || operator.equals("-"))    
            return 1;  
        else if (operator.equals("*") || operator.equals("/"))    
            return 2;    
        else   
            return 0;    
    }    
   
    // 做2值之间的计算    
    public static String twoResult(String operator, String a, String b) ...{    
        try ...{    
            String op = operator;    
            String rs = new String();    
            double x = Double.parseDouble(b);    
            double y = Double.parseDouble(a);    
            double z = 0;    
            if (op.equals("+"))    
                z = x + y;    
            else if (op.equals("-"))    
                z = x - y;    
            else if (op.equals("*"))    
                z = x * y;    
            else if (op.equals("/"))    
                z = x / y;    
            else   
                z = 0;    
            return rs + z;    
        } catch (NumberFormatException e) ...{    
            System.out.println("input has something wrong!");    
            return "Error";    
        }    
    }    
}