Se incorpora mejoras en la función de limpieza y formateo que permite ajustar la calidad y la precisión de la expresión de entrada, eliminando cualquier elemento innecesario y corrigiendo posibles errores de formateo.
Código Java (InfijoPostfijo.java):
package infijopostfijo;
import java.util.Scanner;
import java.util.Stack;
public class InfijoPostfijo {
public static void main(String[] args) {
// Declaración de las pilas
Stack<String> E = new Stack<>(); // Pila entrada
Stack<String> P = new Stack<>(); // Pila temporal para operadores
Stack<String> S = new Stack<>(); // Pila salida
// Entrada de datos
System.out.println("> Ingresa expresión algebraica a convertir:");
Scanner leer = new Scanner(System.in);
// Pasar expresión algebraica a la Pila de entrada (E)
String[] arrayInfix = formato(leer.nextLine()).split(" ");
for (int i = arrayInfix.length - 1; i >= 0; i--) {
E.push(arrayInfix[i]);
}
// Conversor Infijo a Postfijo
while (!E.isEmpty()) {
switch (prioridad(E.peek())) {
case 1 ->
P.push(E.pop());
case 2 -> {
while (!P.peek().equals("(")) {
S.push(P.pop());
}
P.pop();
E.pop();
}
case 3, 4 -> {
while (prioridad(P.peek()) >= prioridad(E.peek())) {
S.push(P.pop());
}
P.push(E.pop());
}
case 5 ->
P.push(E.pop());
default ->
S.push(E.pop());
}
}
// Mostrar resultado:
System.out.println("> Expresión en notación Postfija:\n" + S.toString().replaceAll("[\\]\\[,]", ""));
}
// Prioridad de los operadores
private static int prioridad(String op) {
return switch (op) {
case "^" -> 5;
case "*", "/" -> 4;
case "+", "-" -> 3;
case ")" -> 2;
case "(" -> 1;
default -> 99;
};
}
// Formato expresión algebraica
private static String formato(String expr) {
expr = expr.trim();
expr = expr.charAt(0) == '-' ? "0-" + expr.substring(1) : expr;
expr = expr.replaceAll("\\(-(\\d)", "(0-$1");
expr = expr.replaceAll("(\\d)\\(", "$1*(");
expr = expr.replaceAll("\\)(\\d)", ")*$1");
expr = expr.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)|\\^|])", " $1 ");
expr = expr.replaceAll("\\s+", " ");
return "( " + expr + " )";
}
}
Resultado:
run:
> Ingresa expresión algebraica a convertir:
-4(56-3+5)/2-(45+34)+(-23*(-52)6+2)-1
> Expresión en notación Postfija:
0 4 56 3 - 5 + * 2 / - 45 34 + - 0 23 0 52 - * 6 * - 2 + + 1 -
BUILD SUCCESSFUL (total time: 2 seconds)
miércoles, 28 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.4). Mejorar formato de entrada.
lunes, 26 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.3). Añadir operador de potencia ^.
En esta nueva versión añadimos el operador de potencia ^ que faltaba.
Hay que tener en cuenta que el operador de potencia ^ tiene una prioridad muy alta en las expresiones matemáticas, lo que significa que se evalúa antes que los otros operadores.
Código Java (InfijoPostfijo,java):
package infijopostfijo;
import java.util.Scanner;
import java.util.Stack;
public class InfijoPostfijo {
public static void main(String[] args) {
// Declaración de las pilas
Stack<String> E = new Stack<>(); // Pila entrada
Stack<String> P = new Stack<>(); // Pila temporal para operadores
Stack<String> S = new Stack<>(); // Pila salida
// Entrada de datos
System.out.println("> Ingresa expresión algebraica a convertir:");
Scanner leer = new Scanner(System.in);
// Pasar expresión algebraica a la Pila de entrada (E)
String[] arrayInfix = formato(leer.nextLine()).split(" ");
for (int i = arrayInfix.length - 1; i >= 0; i--) {
E.push(arrayInfix[i]);
}
// Conversor Infijo a Postfijo
while (!E.isEmpty()) {
switch (prioridad(E.peek())) {
case 1 -> P.push(E.pop());
case 2 -> {
while (!P.peek().equals("(")) {
S.push(P.pop());
}
P.pop();
E.pop();
}
case 3, 4 -> {
while (prioridad(P.peek()) >= prioridad(E.peek())) {
S.push(P.pop());
}
P.push(E.pop());
}
case 5 -> P.push(E.pop());
default -> S.push(E.pop());
}
}
// Mostrar resultado:
System.out.println("> Resultado en notación postfija:\n" + S.toString().replaceAll("[\\]\\[,]", ""));
}
// Prioridad de los operadores
private static int prioridad(String op) {
return switch (op) {
case "^" -> 5;
case "*", "/" -> 4;
case "+", "-" -> 3;
case ")" -> 2;
case "(" -> 1;
default -> 99;
};
}
// Formato expresión algebraica
private static String formato(String s) {
return "( " + s.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)|\\^|])", " $1 ").replaceAll("\\s+", " ") + " )";
}
}
Resultado:
run:
> Ingresa expresión algebraica a convertir:
(((34/2)+(43-5-32))^2*2+45-3+(34*2)/5)-1
> Resultado en notación postfija:
34 2 / 43 5 - 32 - + 2 ^ 2 * 45 + 3 - 34 2 * 5 / + 1 -
BUILD SUCCESSFUL (total time: 3 seconds)
domingo, 25 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.2)
package infijopostfijo;
import java.util.Scanner;
import java.util.Stack;
public class InfijoPostfijo {
public static void main(String[] args) {
// Declaración de las pilas
Stack<String> E = new Stack<>(); // Pila entrada
Stack<String> P = new Stack<>(); // Pila temporal para operadores
Stack<String> S = new Stack<>(); // Pila salida
// Entrada de datos
System.out.println("> Ingresa una expresión algebraica: ");
Scanner leer = new Scanner(System.in);
// Pasar expresión algebraica a la Pila de entrada (E)
String[] arrayInfix = formato(leer.nextLine()).split(" ");
for (int i = arrayInfix.length - 1; i >= 0; i--) {
E.push(arrayInfix[i]);
}
// Conversor Infijo a Postfijo
while (!E.isEmpty()) {
switch (prioridad(E.peek())) {
case 1 -> P.push(E.pop());
case 2 -> {
while (!P.peek().equals("(")) {
S.push(P.pop());
}
P.pop();
E.pop();
}
case 3, 4 -> {
while (prioridad(P.peek()) >= prioridad(E.peek())) {
S.push(P.pop());
}
P.push(E.pop());
}
default -> S.push(E.pop());
}
}
// Mostrar resultado:
System.out.println("> Expresión Postfija:\n" + S.toString().replaceAll("[\\]\\[,]", ""));
}
// Prioridad de los operadores
private static int prioridad(String op) {
return switch (op) {
case "*", "/" -> 4;
case "+", "-" -> 3;
case ")" -> 2;
case "(" -> 1;
default -> 99;
};
}
// Formato expresión algebraica
private static String formato(String s) {
return "( " + s.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)])", " $1 ").replaceAll("\\s+", " ") + " )";
}
}
Resultado:
run:
> Ingresa una expresión algebraica:
2*(23+6)-1
> Expresión Postfija:
2 23 6 + * 1 -
BUILD SUCCESSFUL (total time: 7 seconds)