Infijo => Postfijo

Hacer un programa en C que mediante el uso de pilas, transforme una expresión infija a una postfija, nada complicado(en teoría).

Requiere el uso de estos 2 archivos:

pilas.h
pilas.c

Algoritmo y código:
/* 
* Archivo: main.c
* Autores: Antonio Feregrino y Rodrigo Benavides
*
* Creado el 14 de febrero de 2011, 08:22 PM
*/

#include "pilas.h"

int comprobar(char);
int precedencia(char);

/*
* 
*/
int main() {
char primera_expresion[50];//Cadena inicial
char *cadenita_auxiliar = calloc(50+1,sizeof(char));//Cadena final
pila *operadores = crear();//Se crea la pila de los operadores
printf("Introduce la expresión a convertir: \n\n");
gets(primera_expresion);//Se lee la expresion principal
int i = 0, i_cadenita = 0;//Variables usadas para recorrer los arreglos de caracteres
while(primera_expresion[i] != '\0'){//Mientras que la expresión principal no se termine

switch(comprobar(primera_expresion[i])){//Comprobación del tipo de caracter 1 a 1
case 1://En este caso el caracter es un parentesis de apertura (
push(primera_expresion[i],operadores);
break;
case 2://En este caso el caracter es un parentesis de cierre )
while(muestra_ultimo(operadores) != '('){//Mientras que el último elemento de la pila no sea (
cadenita_auxiliar[i_cadenita] = pop(operadores);//Saca los operadores de la pila y colocalos en la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
}
pop(operadores);//Saca el paréntesis de apertura (
break;
case 3://En este caso el caracter es un operando [a-zA-Z0-9]
cadenita_auxiliar[i_cadenita] = primera_expresion[i];//Se introdue directamente a la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
break;
case 4://En este cuarto y último caso, el caracter es un operador [+-/%^]
if(vacia(operadores)){//Si la pila esta vacía
push(primera_expresion[i],operadores);//Introduce el operador
}else{//Si no está vacía
int operador_nv = precedencia(primera_expresion[i]);//Se calcula la precedencia del caracter a evaluar
int operador_ol = precedencia(muestra_ultimo(operadores));//Se calcula la precedencia de la cima
if( operador_nv > operador_ol)//Si la precedencia del nuevo es mayor a la de la cima
{
push(primera_expresion[i],operadores);//Introduce el operador
}
else//Si es menor o igual
{
do{
cadenita_auxiliar[i_cadenita] = pop(operadores);//Saca la cima e introducela en la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
operador_ol = precedencia(muestra_ultimo(operadores));//Calcula la precedencia de la nueva cima
}while(!(operador_nv > operador_ol));//Repite esto hasta que la precedencia del nuevo sea mayor a la de la cima
push(primera_expresion[i],operadores);//Introduce el nuevo operador en la cima de la pila
}
}
break;

}
i++;//Recorre en uno el índice de la expresión inicial
} 
printf("Tu expresión postfija es: %s\n",cadenita_auxiliar);//Muestra la cadena final
return (EXIT_SUCCESS);
}

int comprobar(char t){
/* Función que comprueba que caracter es, regresa valores enteros segun sea el caso */
if( t == '(' ) return 1;
if( t == ')' ) return 2;
if(( t <= 90 && t >=65 ) || ( t <= 122 && t >= 97 ) || ( t <= 57 && t >=48 )) return 3;
if( t == '*' || t == '+' || t == '^' || t == '/' || t == '-') return 4;
else return 0;
}

int precedencia(char t){
/* Aquí es calculada la precedencia personalizada de los operadores */
if( t == '^' ) return 3;
if( t == '*' || t == '/' || t == '%' ) return 2;
if( t == '+' || t == '-' ) return 1;
if( t == '(' || t == ')' ) return 0;
else return 0;
}



No es el mejor algoritmo pero es lo más que pudimos hacer mi compañero y amigo @frescasandia y yo.


Igual no se si esté permitido por la profesora @bellims hacer esto ;$

¡No al plagio!

¡Saludos! @fferegrino :)

4 comments:

¡Hey, gracias por tu comentario! No seas anónimo, inicia sesión para que te responda más fácilmente.