Conversión de expresiones infijas en expresiones postfijas

Tengo un problema, no puedo encontrar el error en esta función, a veces funciona bien con cualquier entrada, pero se almacena en caché cuando hay paréntesis en la entrada {quiero saber dónde está el error en este código y cómo solucionarlo, y ¿Hay otra manera mejor en lugar de esta manera?}

    public static String Converting_infix_expressions_to_postfix_expressions(String infix) throws Exception{
    StringTokenizer st = new StringTokenizer(infix);
    int numOF_tokens = st.countTokens();
    String postfix = "" ;
    for (int i = 1; i <= numOF_tokens; i++) {
        String term = st.nextToken();
        try {  // if it is an Float there is no problem will happen
            float x =  Float.parseFloat(term);
            postfix += x +" " ;
            System.out.println("term is number " + term);
        } catch (Exception e) {
            System.out.println("term is symbol " + term);
            if(stack.isEmpty())
                stack.push(term);
            else if(term == "(")
                stack.push(term);
            else if(term == ")"){
                while((String)stack.peek() != "(")
                    postfix += stack.pop() +" ";
                stack.pop();
            }

            else{
                int x = 0,y = 0;
                switch(term){
                case "+": x = 1; break;
                case "-": x = 1; break;
                case "*": x = 2; break;
                case "/": x = 2; break;
                }
                switch((String)stack.peek()){
                case "+": y = 1; break;
                case "-": y = 1; break;
                case "*": y = 2; break;
                case "/": y = 2; break;
                }
                if(x > y)
                    stack.push(term);
                else {
                    int x1 = x , y1 = y;
                    boolean puchedBefore = false;
                    while(x1 <= y1){
                        postfix += stack.pop() +" ";
                        if(stack.isEmpty() || stack.peek() == "(" ){
                            stack.push(term);
                            puchedBefore = true;
                            break;
                        }
                        else{
                            switch(term){
                            case "+": x1 = 1; break;
                            case "-": x1 = 1; break;
                            case "*": x1 = 2; break;
                            case "/": x1 = 2; break;
                            }
                            switch((String)stack.peek()){
                            case "+": y1 = 1; break;
                            case "-": y1 = 1; break;
                            case "*": y1 = 2; break;
                            case "/": y1 = 2; break;
                            }
                        }
                    }
                    if(!puchedBefore)
                        stack.push(term);
                }   
            }
        }
    }
    while(!stack.isEmpty()){
        postfix += stack.pop() +" ";
    }
    System.out.println("The postfix expression is : " + postfix);
    return postfix;
}

preguntado el 03 de mayo de 12 a las 16:05

¿Has probado a depurar? Obtenga un caso que sepa que falla y establezca un punto de interrupción, luego avance para ver dónde está tomando una decisión que no tiene sentido para usted. Además, los ejemplos de expresiones que funcionan (y su resultado) y las que no funcionan (y su resultado) ayudarían a que esta sea una mejor pregunta. -

Hay bastante repetición en el código... ¿Consideró escribir un analizador recursivo descendente en su lugar? -

¿Ha considerado el Algoritmo de patio de maniobras? -

1 Respuestas

Tiene un par de problemas con su código.

  1. Debe crear un tokenizador de cadena personalizado, ya que es posible que no haya un espacio entre un paréntesis y un número. Ej: (5 + 6)
  2. El bloque try-catch no se está utilizando correctamente. Considere, primero verificar si el campo es un símbolo y luego pasar a analizarlo como un Flotante. De esta manera, puede evitar que la mayor parte de su código aparezca en el bloque catch.
  3. El error al que se refiere se puede solucionar con el siguiente cambio en la línea 18.

    while(!stack.isEmpty() && (String)stack.peek() != "(")

contestado el 03 de mayo de 12 a las 16:05

La misma respuesta, pero quiero que Sting regrese sin paréntesis de una buena manera sin eliminar los paréntesis al final de la expresión: mohsen

esta es una entrada con la que el programa falló 1 * 2 + 3 * ( 5 + 2 ) - 3 ; - mohsen

¿Has probado la solución n. ° 3 que mencioné anteriormente? Creo que simplemente olvidaste verificar si la pila no está vacía. Por cierto, ¿es esta tu tarea? - user845279

sí, probé el n. ° 3 pero tiene el mismo resultado. pero el problema que tengo es que todavía pensé que el código anterior (con sus instrucciones n. ° 3) debería solucionar el problema con entradas con paréntesis como 1 * 2 + 3 * (5 + 2) - 3 y generar la excepción de postfijo sin paréntesis pero el resultado es 1.0 2.0 * 3.0 * + 5.0 2.0 + (3.0 -) así que quiero saber por qué este código no puede manejar este caso - mohsen

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.