• Sábado 14 de Diciembre de 2024, 12:27
« anterior próximo »
Páginas: [1]

Autor Tema:  evaluar expresion postfija  (Leído 10090 veces)

antlcn

  • Nuevo Miembro
  • *
  • Mensajes: 12
    • Ver Perfil
evaluar expresion postfija
« en: Domingo 30 de Mayo de 2010, 16:14 »
0
hola, necesito hacer un programa en C al que le introduzcas una expresion postfija y te devuelva el resultado la expresion se guarda en una cadena con expacios entre cada dato introducido con un caracter final de parada "f", y no me funciona el programa, a ver si alguien sabe en que fallo.
Código: C
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4.  
  5. struct pila{
  6.     int n;
  7.     struct pila *sig;
  8. };
  9.  
  10. void apilar(struct pila **cabeza, int n);
  11. struct pila *nuevoElemento();
  12. int desapilar(struct pila **cabeza);
  13. int pilaVacia(struct pila *cabeza);
  14. int operacion(int n1, int n2, char caract);
  15. void conversion(struct pila *cabeza, char cad[]);
  16. void mostrarPila(struct pila **cabeza);
  17.  
  18. int
  19. main(void)
  20. {
  21.     int res;
  22.     struct pila *operandos=NULL;
  23.     char expresion[15];
  24.     printf("nIntroduce la expresion separada por espacios: ");
  25.     gets(expresion);
  26.     printf("nOk...getsn");
  27.     conversion(operandos, expresion);
  28.     mostrarPila(&operandos);
  29.     printf("nOk..conversionn");
  30.     res=desapilar(&operandos);
  31.     printf("nOk...resultadon");
  32.     printf("nEl resultado de la expresion es: %dn", res);
  33.     return 0;
  34. }
  35.  
  36.  
  37.  
  38. struct pila *nuevoElemento()
  39. {
  40.     return (struct pila *)malloc(sizeof(struct pila));
  41. }
  42.  
  43. void apilar(struct pila **cabeza, int n)
  44. {
  45.     struct pila *nuevo=NULL;
  46.     nuevo=nuevoElemento();
  47.     nuevo->n=n;
  48.     nuevo->sig=*cabeza;
  49.     *cabeza=nuevo;
  50. }
  51.  
  52. int desapilar(struct pila **cabeza)
  53. {
  54.     int n;
  55.     struct pila *aux=NULL;
  56.     n=(*cabeza)->n;
  57.     aux=*cabeza;
  58.     *cabeza=aux->sig;
  59.     free(aux);
  60.     return n;
  61. }
  62.  
  63. int pilaVacia(struct pila *cabeza)
  64. {
  65.     if(cabeza==NULL)
  66.         return 0;
  67.     return 1;
  68. }
  69.  
  70. int operacion(int n1, int n2, char caract)
  71. {
  72.     int r;
  73.     if(caract=='*')
  74.         r= n1*n2;
  75.     if(caract=='-')
  76.         r= n1-n2;
  77.     if(caract=='+')
  78.         r= n1+n2;
  79.     if(caract=='/')
  80.         r= n1/n2;
  81.     return r;
  82. }
  83.  
  84. void conversion(struct pila *cabeza, char cad[])
  85. {
  86.     int n1, n2, nuevo, i=0;
  87.     while(cad[i]!='f'){
  88.         if(cad[i]>47 && cad[i]<57)
  89.             apilar(&cabeza, cad[i]);
  90.         if(cad[i]>41 && cad[i]<47){
  91.             n1=desapilar(&cabeza);
  92.             n2=desapilar(&cabeza);
  93.             nuevo=operacion(n1, n2, cad[i]);
  94.             apilar(&cabeza, nuevo);
  95.         }
  96.         i++;
  97.     }
  98.    
  99. }
  100.  
  101.  
  102. void mostrarPila(struct pila **cabeza)
  103. {
  104.     struct pila *aux=NULL;
  105.     aux=*cabeza;
  106.     while(aux!=NULL){
  107.         printf("n%d",aux->n);
  108.     }
  109. }
  110.  


un saludo.

gracias de antemano.

czealt

  • Miembro activo
  • **
  • Mensajes: 28
    • Ver Perfil
Re: evaluar expresion postfija
« Respuesta #1 en: Jueves 10 de Junio de 2010, 06:26 »
0
..Los errores que hacen que el programa no funcione estan en la funcion conversion():
Código: C
  1.  
  2. void conversion(struct pila *cabeza, char cad[]) /* esta funcion modifica la pila asi que el argumento cabeza deberia ser declarado como struct pila **cabeza */
  3. {
  4.     int n1, n2, nuevo, i=0;
  5.     while(cad[i]!='f'){
  6.         if(cad[i]>47 && cad[i]<57)
  7.             apilar(&cabeza, cad[i]); /* Aqui se esta apilando el codigo ASCII del digito en lugar de su valor */
  8.         if(cad[i]>41 && cad[i]<47){
  9.             n1=desapilar(&cabeza); /* El operando que se desapila primero debe ser n2*/
  10.             n2=desapilar(&cabeza);
  11.             nuevo=operacion(n1, n2, cad[i]);
  12.             apilar(&cabeza, nuevo);
  13.         }
  14.         i++;
  15.     }
  16. }
  17.  
  18.  
  19.  

Tambien se deberia verificar si el segundo operando de la operacion / es cero para evitar dividir por 0.

El programa corregido:
Código: C
  1.  
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5.  
  6. enum{DIVCERO=1};
  7.  
  8. const char *msjerror[]={"Division por cero"};
  9.  
  10. int erroreval=0;
  11.  
  12. struct pila{
  13.     int n;
  14.     struct pila *sig;
  15. };
  16.  
  17. void apilar(struct pila **cabeza, int n);
  18. struct pila *nuevoElemento();
  19. int desapilar(struct pila **cabeza);
  20. int pilaVacia(struct pila *cabeza);
  21. int operacion(int n1, int n2, char caract);
  22. void conversion(struct pila **cabeza, char cad[]);
  23. void mostrarPila(struct pila **cabeza);
  24.  
  25. int main(void)
  26. {
  27.     int res;
  28.     struct pila *operandos=NULL;
  29.     char expresion[15];
  30.     printf("nIntroduce la expresion separada por espacios: ");
  31.     gets(expresion);
  32.     printf("nOk...getsn");
  33.     conversion(&operandos, expresion);
  34.     mostrarPila(&operandos);
  35.     if(erroreval)
  36.     {
  37.         printf("Error de evaluacion: %sn",msjerror[erroreval-1]);
  38.     }
  39.     else
  40.     {
  41.         printf("nOk..conversionn");
  42.         res=desapilar(&operandos);
  43.         printf("nOk...resultadon");
  44.         printf("nEl resultado de la expresion es: %dn", res);
  45.     }
  46.     return 0;
  47. }
  48.  
  49.  
  50.  
  51. struct pila *nuevoElemento()
  52. {
  53.     return (struct pila *)malloc(sizeof(struct pila));
  54. }
  55.  
  56. void apilar(struct pila **cabeza, int n)
  57. {
  58.     struct pila *nuevo=NULL;
  59.     nuevo=nuevoElemento();
  60.     nuevo->n=n;
  61.     nuevo->sig=*cabeza;
  62.     *cabeza=nuevo;
  63. }
  64.  
  65. int desapilar(struct pila **cabeza)
  66. {
  67.     int n;
  68.     struct pila *aux=NULL;
  69.     n=(*cabeza)->n;
  70.     aux=*cabeza;
  71.     *cabeza=aux->sig;
  72.     free(aux);
  73.     return n;
  74. }
  75.  
  76. int pilaVacia(struct pila *cabeza)
  77. {
  78.     if(cabeza==NULL)
  79.         return 0;
  80.     return 1;
  81. }
  82.  
  83. int operacion(int n1, int n2, char caract)
  84. {
  85.     int r;
  86.     erroreval=0;
  87.     if(caract=='*')
  88.         r= n1*n2;
  89.     if(caract=='-')
  90.         r= n1-n2;
  91.     if(caract=='+')
  92.         r= n1+n2;
  93.     if(caract=='/')// verificar que n2 no sea 0
  94.     {
  95.         if(n2!=0)
  96.             r= n1/n2;
  97.         else
  98.             erroreval=DIVCERO;
  99.     }
  100.     return r;
  101. }
  102.  
  103. void conversion(struct pila **cabeza, char cad[])
  104. {
  105.     int n1, n2, nuevo, i=0;
  106.     while(cad[i]!='f'){
  107.         if(cad[i]>='0' && cad[i]<='9') // es digito?
  108.             apilar(cabeza, cad[i]-'0'); // convertir a entero antes de apilar
  109.         if(cad[i]=='+' || cad[i]=='-' ||
  110.            cad[i]=='*' || cad[i]=='/'){// es operacion?
  111.             n2=desapilar(cabeza);
  112.             n1=desapilar(cabeza);
  113.             nuevo=operacion(n1, n2, cad[i]);
  114.             apilar(cabeza, nuevo);
  115.         }
  116.         i++;
  117.     }
  118. }
  119.  
  120.  
  121. void mostrarPila(struct pila **cabeza)
  122. {
  123.     struct pila *aux=NULL;
  124.     aux=*cabeza;
  125.     while(aux!=NULL){
  126.         printf("n%d",aux->n);
  127.         aux=aux->sig;
  128.     }
  129. }
  130.  
  131.  
Páginas: [1]
« anterior próximo »