s, 20 de septiembre de 2012

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. (

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 BUILD SUCCESSFUL (total time: 4 seconds)