Primeros pasos para conversin notacin Infija a Postfija.

La notacin Postfija es un mtodo algebraico alternativo de

introduccin de datos que permite reducir el acceso a la memoria
del ordenador, sobretodo en calculos masivos y complejos ya
que los clculos se realizan secuencialmente segn se van
introduciendo los operadores (en vez de tener que esperar a
escribir la expresin al completo).
Basicamente consiste en que en una expresin de ese tipo primero
estn los operandos y despus viene el operador.
Ej:
"3+5" pasado a notacin Postfija seria: "3 5 +"

* Pasos para la conversin Infijo a Postfijo usando pilas.

EXPR = Expresin aritmtica notacin infija ( Ej: 2*(23+6)1 )
E = pila de entrada
P = pila temporal para los operadores
S = pila de salida
1.- Aadir ( 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 vaca.
3.- Si se encuentra (, meterlo en P.
4.- Si se encuentra un OPERADOR (+,-,*,/,^) entonces:
(a) Repetidamente sacar de P y aadir a S cada operador (de
la cima de P) que tenga la misma precedencia o mayor que el
operador de E.
(b) Aadir OPERADOR a P.
[Fin de condicional]

5.- Si se encuentra un ), entonces:

(a) Repetidamente sacar de P y aadir a S cada operador (de
la cima de P), hasta que encuentre un (.
(b) Eliminar el ( de P (no aadir a S).
[Fin de condicional]
6.- Si se encuentra un OPERANDO (2,23,6), aadirlo a S.
[Fin del Bucle]
7.- Salir.
Nota: Los operadores siguen la siguiente jerarqua (El de arriba
es el que tiene mayor jerarqua hasta abajo el que tiene la
menor):
1. ^
2. *

3. +

4. )
5. (

* Diagrama de flujo:

Conversin de Infijo a Postfijo usando pilas

Ver referencia: Infijo-Posfijo
Codigo:
//Conversin de notacin Infija a Postfija mediante uso de
pilas
package 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 expresin algebraica:
");
Scanner leer = new Scanner(System.in);
//Depurar la expresion algebraica
String expr = depurar(leer.nextLine());
String[] arrayInfix = expr.split(" ");
//Declaracin de las
Stack < String > E =
entrada
Stack < String > P =
temporal para operadores
Stack < String > S =
salida

pilas
new Stack < String > (); //Pila
new Stack < String > (); //Pila
new Stack < String > (); //Pila

//Aadir 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 expresin algebraica");
System.err.println(ex);
}
}
//Depurar expresin 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 expresin algebraica:
2*(23+6)-1
Expresion Infija: (2*(23+6)-1)
Expresion Postfija: 2 23 6 + * 1 -

Evaluar expresin Postfija usando pilas.

Codigo:
// Evaluar expresin en notacin Postfija (solo num enteros)
package evalpost;
import java.util.Stack;
public class EvalPost {
public static void main(String[] args) {
//Entrada (Expresin en Postfija)
String expr = "2 23 6 + * 1 -"; // equivale a 2*(23+6)-1

String[] post = expr.split(" ");

//Declaracin de las pilas
Stack < String > E = new Stack < String > (); //Pila
entrada
Stack < String > P = new Stack < String > (); //Pila de
operandos
//Aadir post (array) a la Pila de entrada (E)
for (int i = post.length - 1; i >= 0; i--) {
E.push(post[i]);
}
//Algoritmo de Evaluacin 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
if (op.equals("-")) return (num1
if (op.equals("*")) return (num1
if (op.equals("/")) return (num1
if (op.equals("%")) return (num1
return 0;
}
}

+
*
/
%

num2);
num2);
num2);
num2);
num2);