Ayuda ... por favor.

[pperalta]

Hola foro.
Bueno les paso a explicar mi problema.
Tengo que resolver un algoritmo utilizando un TDA "PILA".
El enunciado del ejercicio sería el siguiente:

Realizar un algoritmo que permita controlar el balanceo de símbolos en una operación matemática, esto es los corchetes, llaves y peréntesis derechos deben corresponder a su contraparte izquierda. La secuencia {[()]} es correcta, en cambio {]})
es errónea. Por simplicidad sólo se desea evaluar el equilibrio de paréntesis, llaves y corchetes, ignorando cualquier otro caracter que aparezca.
Se debe permitir ingresar la operación matemática completa y luego emitir un mensaje si es correcto. En caso contrario mostrar cual es el primer símbolo que no balancea.

El TAD lo tengo y el fuente también, el problema que tengo es que sismpre me da un mensaje erróneo aunque tenga bien la operación matemática.
Si necesitan ver el fuente que tengo y el TDA, se los paso.
Sino... Si alguien tiene algo parecido me pasaría como lo resolbió???
Saludos cordiales.

[ivancp]

Cual es el mensaje y numero de error?
Que lineas de codigo produce el error?

[pperalta]

Hola Ivan.
Te paso mejor el código del ".h" y el ".cpp". por que en realidad el problema que tengo; es que por más que la operación matemática esté bien o mal siempre de devuelve "La opreración NO correcta" ... algo estoy haciendo mal.
Te paso mejor el TDA Pila ...

Código: Seleccionar todo

#include <iostream.h>
#include <stdio.h>
#include <conio.h>

const max_elementos = 10;

typedef char Tipo_elemento;

struct Pila
{
   Tipo_elemento elementos[max_elementos];
   int tope;
};

typedef Pila parm_Pila;

void crear_pila(parm_Pila &pile);
int esvacia_pila(parm_Pila pile);
int estallena_pila(parm_Pila pile);
int apilar_pila(Tipo_elemento &elemento, parm_Pila &pile);
int desapilar_pila(Tipo_elemento &elemento, parm_Pila &pile);
int tope_pila(parm_Pila pile, Tipo_elemento &elemento);

void crear_pila(parm_Pila &pile)
{
   pile.tope=-1;
   cout<<"Pila inicializada = "<<pile.tope<<endl;
}

int esvacia_pila(parm_Pila pile)
{
   if (pile.tope == -1)
   {
      return 1;
   }else
   {
      return 0;
   }      
}

int estallena_pila(parm_Pila pile)
{
   if(pile.tope == max_elementos-1)
   {
      return 1;
   }else
   {
      return 0;
   }
}

int apilar_pila(Tipo_elemento &elemento, parm_Pila &pile)
{
   if(estallena_pila(pile))
   {
      return 0;
   }else
   {
        pile.tope ++;
      pile.elementos [pile.tope] = elemento;
      return 1;
   }
}

int desapilar_pila(Tipo_elemento &elemento, parm_Pila &pile)
{
   if(esvacia_pila(pile))
   {
      return 0;
   }else
   {
      elemento = pile.elementos[pile.tope];
      pile.tope--;
      return 1;
   }
}

int tope_pila(parm_Pila pile, Tipo_elemento &elemento)
{
   if(esvacia_pila(pile))
   {
      return 0;
   }else
   {
      elemento = pile.elementos[pile.tope];
      return 1;
   }

}
********************************************************************************************************************************************
Y aca te paso el fuente ....
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "Pila.h"


void main(void)
{
   int x;
   char simbolo;
   char operacion[15];
   Pila pila;
       
       crear_pila(pila);
      
        cout<<"Ingrese una operacion matematica : ";
        cin>>operacion;
     
      for(x=0; x<15; x++)
      {
         if((operacion[x]=='{') || (operacion[x]=='[') || (operacion[x]=='('))
         {
            apilar_pila(operacion[x], pila);
            cout<<"Operacion = ";
            cout<<operacion[x]<<" "<<x<<endl;
            cout<<endl;
            // hasta aca apila en el orden ingresado.
         }
         else
         {
            if((operacion[x]=='}') || (operacion[x]==']') || (operacion[x]==')'))
            {
               tope_pila(pila, simbolo);
                                        desapilar_pila(pila, simbolo);   
                                        //--------------------------------------------------------------------
               //pero a partir de aca "simbolo" toma siempre el ultimo simbolo de
               //operación por ej. {[()]}
               //"simbolo" toma el parentesis habierto "(" y lo compara con "), ], }"
               // de "operacion"; dando siempre que la expresión es incorrecta.
               // Puede que el desapilar no esté desapilando
               //--------------------------------------------------------------------
               cout<<"if de simbolos contrarios = ";
               cout<<"simbolo ="<<simbolo<<", operacion ="<<operacion[x]<<endl;
               if((operacion[x]=='{') && (simbolo=='}'))
               {
                  desapilar_pila(operacion[x], pila);
                  return;
               }
               cout<<endl;
               cout<<"1er. if"<<endl;
               cout<<"simbolo = "<<simbolo<<", operacion = "<<operacion[x]<<endl;
            
               if((operacion[x]=='[') && (simbolo==']'))
               {
                  desapilar_pila(operacion[x], pila);
                  return;
               }   
               cout<<endl;
               cout<<"2do. if"<<endl;
               cout<<"simbolo = "<<simbolo<<", operacion = "<<operacion[x]<<endl;
               
               if((operacion[x]=='(') && (simbolo==')'))
               {
                  desapilar_pila(operacion[x], pila);
                  return;
                  
               }
               cout<<endl;
               cout<<"3er. if"<<endl;
               cout<<"simbolo = "<<simbolo<<", operacion = "<<operacion[x]<<endl;
               }
         }
         
      }
       
      if(esvacia_pila(pila)==1)
        {
         cout<<"La operacion es correcta."<<endl;
      }
      else
      {
         cout<<"La operacion NO es correcta."<<endl;
      }

Si lo probás y ves cual es el problema te agradecería que me indiques en que línea o función estoy logicamente errado.
Saludos cordiales.

[ivancp]

Hola,

Entender el codigo de otros es mas tedioso de lo que te imaginas, me demoré menos en implementar una pila que hace lo que necesitas.

Este es el ejemplo de ejecucion de la pila:

Código: Seleccionar todo

C:\Documents and Settings\pc_03\Mis documentos>nuevapila < expresiones.txt
Analizando: '{9+[3-(4-8)]+8*6}'  Ok!
Analizando: '(2+2)'  Ok!
Analizando: '{[()]}'  Ok!
Analizando: '' Analizando: '9+[3-(4-8)]+8*6}'
        Error en el caracter 15 al procesar : }
        Error se esperaba el cierre de
Analizando: '2+2)'
        Error en el caracter 3 al procesar : )
        Error se esperaba el cierre de
Analizando: '{[()}'
        Error en el caracter 4 al procesar : }
        Error se esperaba el cierre de [

C:\Documents and Settings\pc_03\Mis documentos>

El archivo expresiones.txt contiene lo siguiente:

Código: Seleccionar todo

{9+[3-(4-8)]+8*6}
(2+2)
{[()]}

9+[3-(4-8)]+8*6}
2+2)
{[()}

No hago la tarea por otros, lo unico que me animo es saber en cuando tiempo podía implementarlo (15min).

La proxima vez tienes que explicar mejor tu problema. y encerrar tu codigo con las etiquetas "code".

Saludos.