Primeros pasos para conversión notación Infija a Postfija.

La notación Postfija es un método algebraico alternativo de introducción de datos que permite reducir el acceso a la memoria del ordenador, sobretodo en calculos masivos y complejos ya que los cálculos se realizan secuencialmente según se van introduciendo los operadores (en vez de tener que esperar a escribir la expresión al completo).Basicamente consiste en que en una expresión de ese tipo primero están los operandos y después viene el operador. 

Ej:

         "3+5" pasado a notación Postfija seria: "3 5 +" 

* Pasos para la conversión   Infijo a Postfijo usando pilas.   

     EXPR = Expresión aritmética notación infija ( Ej: 2*(23+6)-1 )

     E = pila de entrada     P = pila temporal para los operadores     S = pila de salida  

1.- Añadir “(” al principio y “)” al final de EXPR. Seguidamente agregar uno a uno todos los parametros de EXPR a la Pila E.

(,2,*,(,23,+,6,),-,1,)

2.- Examinar E de izquierda a derecha y repetir los pasos 3 a 6 para cada elemento de E hasta que esta quede vacía.

3.- Si se encuentra “(”, meterlo en P.

4.- Si se encuentra un OPERADOR (+,-,*,/,^) entonces:

     (a) Repetidamente sacar de P y añadir a S cada operador (de la cima de P) que tenga la misma precedencia o mayor que el operador de E.

     (b) Añadir OPERADOR a P.

[Fin de condicional]

5.- Si se encuentra un “)”, entonces:

     (a) Repetidamente sacar de P y añadir a S cada operador (de la cima de P), hasta que encuentre un “(”.

     (b) Eliminar el “(” de P (no añadir a S).

[Fin de condicional]

6.- Si se encuentra un OPERANDO (2,23,6…), añadirlo a S.

[Fin del Bucle]

7.- Salir.

Nota: Los operadores siguen la siguiente jerarquía (El de arriba es el que tiene mayor jerarquía hasta abajo el que tiene la menor): 

1. ^2. *  /3. +  -4. )5. (

* Diagrama de flujo:

http://3.bp.blogspot.com/-1BjuvlXpCeA/UFuT-cdxV8I/AAAAAAAAAPk/KYdTb9F_mks/s1600/Infix-Postfix.PNG

Conversión de Infijo a Postfijo usando pilas

Ver referencia: Infijo-Posfijo

Codigo:

//Conversión de notación Infija a Postfija mediante uso de pilaspackage infixpostfix4;

import java.util.Scanner;import java.util.Stack;

public class InfixPostfix4 {  public static void main(String[] args) {

    //Entrada de datos    System.out.println("*Escribe una expresión algebraica: ");    Scanner leer = new Scanner(System.in);

    //Depurar la expresion algebraica    String expr = depurar(leer.nextLine());    String[] arrayInfix = expr.split(" ");

    //Declaración de las pilas    Stack < String > E = new Stack < String > (); //Pila entrada    Stack < String > P = new Stack < String > (); //Pila temporal para operadores    Stack < String > S = new Stack < String > (); //Pila salida

    //Añadir la array a la Pila de entrada (E)    for (int i = arrayInfix.length - 1; i >= 0; i--) {      E.push(arrayInfix[i]);    }

    try {      //Algoritmo Infijo a Postfijo      while (!E.isEmpty()) {

        switch (pref(E.peek())){          case 1:            P.push(E.pop());            break;          case 3:          case 4:            while(pref(P.peek()) >= pref(E.peek())) {              S.push(P.pop());            }            P.push(E.pop());            break;           case 2:            while(!P.peek().equals("(")) {              S.push(P.pop());            }            P.pop();            E.pop();            break;           default:            S.push(E.pop());         }       } 

      //Eliminacion de `impurezas´ en la expresiones algebraicas      String infix = expr.replace(" ", "");      String postfix = S.toString().replaceAll("[\\]\\[,]", "");

      //Mostrar resultados:      System.out.println("Expresion Infija: " + infix);      System.out.println("Expresion Postfija: " + postfix);

    }catch(Exception ex){       System.out.println("Error en la expresión algebraica");      System.err.println(ex);    }  } 

  //Depurar expresión algebraica  private static String depurar(String s) {    s = s.replaceAll("\\s+", ""); //Elimina espacios en blanco    s = "(" + s + ")";    String simbols = "+-*/()";    String str = "";  

    //Deja espacios entre operadores    for (int i = 0; i < s.length(); i++) {      if (simbols.contains("" + s.charAt(i))) {        str += " " + s.charAt(i) + " ";      }else str += s.charAt(i);    }    return str.replaceAll("\\s+", " ").trim();  } 

  //Jerarquia de los operadores  private static int pref(String op) {    int prf = 99;    if (op.equals("^")) prf = 5;    if (op.equals("*") || op.equals("/")) prf = 4;    if (op.equals("+") || op.equals("-")) prf = 3;    if (op.equals(")")) prf = 2;    if (op.equals("(")) prf = 1;    return prf;  }}

Resultado:

run:*Escribe una expresión algebraica:2*(23+6)-1Expresion Infija: (2*(23+6)-1)Expresion Postfija: 2 23 6 + * 1 -

Evaluar expresión Postfija usando pilas.

Codigo:

// Evaluar expresión en notación Postfija (solo num enteros)package evalpost;

import java.util.Stack;

public class EvalPost {  public static void main(String[] args) {           //Entrada (Expresión en Postfija)    String expr = "2 23 6 + * 1 -"; // equivale a 2*(23+6)-1

    String[] post = expr.split(" ");            //Declaración de las pilas    Stack < String > E = new Stack < String > (); //Pila entrada    Stack < String > P = new Stack < String > (); //Pila de operandos

    //Añadir post (array) a la Pila de entrada (E)    for (int i = post.length - 1; i >= 0; i--) {      E.push(post[i]);    }

    //Algoritmo de Evaluación Postfija    String operadores = "+-*/%";     while (!E.isEmpty()) {      if (operadores.contains("" + E.peek())) {        P.push(evaluar(E.pop(), P.pop(), P.pop()) + "");      }else {        P.push(E.pop());      }     }

    //Mostrar resultados:    System.out.println("Expresion: " + expr);    System.out.println("Resultado: " + P.peek());

  }

  private static int evaluar(String op, String n2, String n1) {    int num1 = Integer.parseInt(n1);    int num2 = Integer.parseInt(n2);    if (op.equals("+")) return (num1 + num2);    if (op.equals("-")) return (num1 - num2);    if (op.equals("*")) return (num1 * num2);    if (op.equals("/")) return (num1 / num2);    if (op.equals("%")) return (num1 % num2);    return 0;  }

}