0

//这是程序抛出的异常

该程序不会成功编译，它会抛出一个 EmptyCollectionException。

线程“main”中的异常 EmptyCollectionException：La colección está vacía：堆栈下溢。

  at ArrayStack.peek(ArrayStack.java:57)
  at Convertidor.convierte(Convertidor.java:58)
  at postfix.main(postfix.java:20)

Java 结果：1

 public class Convertidor {
//This method will calculate the priority of the operators.
        public  int  prioridad(char e){
            int p, prioridad;
            char ch;
            prioridad=0;
            char[] operadores = new char[] { '+', '-', '*', '/','^' };
            for(p=0;p<operadores.length;p++){
                ch=operadores[p];
                if(p=='+'||p=='-')
                    prioridad=1;
                if(p=='/'||p=='*')
                    prioridad=2;
                if(p=='^')
                    prioridad=3;
            }
            return prioridad;
        }
    
        public  String convierte(String entrada){
            String salida="";
            String resp;
            char e,r,ch;
            String n;
            n="";
            int i, pri,p;
            pri=0;
            StringBuffer buff=new StringBuffer();
            ArrayStack<Character> pila=new ArrayStack<Character>();
            while(!entrada.equals(null)){
            
                for(i=0;i<entrada.length();i++){
                    e=entrada.charAt(i);
                    if(Character.isDigit(e)){
                         buff.append(salida);
                         buff.append(e);
                      }
                 else
                          if(e=='(')
                              pila.push(e);
                        else        
                               if(e==')'){
                                   while(!pila.isEmpty()&&!pila.peek().equals('(')){
                                      n=pila.pop().toString();
                                      buff.append(n);
                                      buff.append("");
                                    }
                                    }              
                      if(e=='+'||e=='-'||e=='*'||e=='/'||e=='^'){
                     while(prioridad(pila.peek())>=prioridad(e)&&!pila.isEmpty()){
                            buff.append(pila.pop());
                         
                     }
                        pila.push(e); 
                           }
                      
            }
                      while(!pila.isEmpty()){
                         buff.append(pila.pop());
                      }
            
                }
                salida=buff.toString();
                return salida;
        
        
        
            }
    
    
    
        }
4

1 回答 1

2

我相信问题出在这条线上：

while(prioridad(pila.peek())>=prioridad(e) && !pila.isEmpty()){

我认为如果您颠倒评估顺序，它应该可以解决问题，因为&&如果第一个表达式为假，运算符将短路评估。这样，它将检查堆栈是否为空，并且仅在它不为空时才偷看。

尝试!pila.isEmpty()像这样制作第一个操作数：

while(!pila.isEmpty() && prioridad(pila.peek())>=prioridad(e)){
于 2013-03-06T03:17:57.200 回答