[Código Fuente] Pila Dinámica

/*******************************/
// pila_dinamica.h
/********************************/

#ifndef _PILA_H
#define _PILA_H

class Pila
{
     private:
             bool Copiar(const Pila& p);
             void Pila::Vaciar();
             struct Nodo;
             typedef Nodo* Puntero;
            
             struct Nodo
             {
                    TipoDato info;
                    Puntero sig;
             };
             Puntero cima;
            
     public:
            Pila();
            Pila (const Pila&); /* COnstructor de copia que se ejecuta cada vez
             que se pasa un parametro a una funcion*/

             ~Pila ();
            typedef int TipoDato;
            const Pila& operator= (const Pila&);
            bool Apilar(TipoDato elemento);
            bool Desapilar();
            bool CimaPila(TipoDato &elemento);    
            bool PilaVacia();
       
};


#endif

/*********************/
// pila_dinamica.cpp
/*********************/

#include <iostream>
#include "pila.h"

using namespace std;

Pila::Pila()
{
           cima = NULL;              
}

Pila::Pila(const Pila& p)
{
if(!Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
}

Pila::~Pila()
{
            Vaciar();
}


bool Pila::Copiar(const Pila& p)
{
    bool ok=true;
    Puntero p_aux, dup, fin;
  
    Vaciar();
    p_aux = p.cima;
          while( (p_aux != NULL) && ok)
          {
                 dup = new Nodo;
                 if (dup == NULL)
                    ok = false;
                 else

                  {
                 dup -> info = p_aux -> info;
                 dup -> sig = NULL;
                 if (cima == NULL) //Si Cima = NULL entonces es la primera copia del nodo.
                     cima = dup;
                 else
                      fin-> sig = dup;
                 fin = dup;
                 p_aux = p_aux->sig;
                 }
          }
}    

return ok;
   
   
}
void Pila::Vaciar()
{
    while(Desapilar());
    cima = NULL;
}

const Pila& Pila::operator= (const Pila& p)
{
     if(! Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
  return (*this);
}


bool Pila::PilaVacia()
{
    return (cima == NULL);    
}

bool Pila::Apilar(TipoDato elemento)
{
    Puntero p;
    p= new Nodo; //Creamos un nuevo puntero
     p -> info = elemento; // Este le añadimos el valor pasado

     p -> sig = cima; // Y apuntamos cima apunta a siguiente
     cima = p;
   
}

bool Pila::Desapilar()
{
    bool ok;
   Puntero p_aux;
   p_aux = cima;
   if(cima == NULL)
           ok = false;
   else

        {
           cima = cima -> sig;
           delete p_aux;
           ok=true;
       }
   return ok;
   
   
}

bool Pila::CimaPila(TipoDato &elemento)
{
    bool ok=true;
    if(cima==NULL)
                  ok=false;
    else

         elemento = cima -> info;
       
        return ok;    
   
}

Leer más…

[Código Fuente] Pila Estática

/*************************************************************/
//                      pila.cpp
/*************************************************************/

#include <iostream>
#include "pila.h"

using namespace std;

Pila::Pila()
{              cima = -1;        
}

bool Pila::Apilar(TipoDato &elemento)
{
bool res;
if(cima == MAX-1)
{   cerr << "Desbordamiento de Pila (Overflow)" << endl;
  res=false;
}else

     {cima++;
pila[cima] = elemento;
res = true;
}
return res;


}

bool Pila::Desapilar()
{
bool res;
if(cima == -1)
{   cerr << "Se esta intentando quitar un elemento de una pila vacia (underflow)" << endl;
  res=false;
}else

     {cima--;
res = true;
}
return res;


}

void Pila::VerPila()
{
for(int i=0;i<=cima;i++)
cout << pila[i] << endl;

}


bool Pila::CimaPila(TipoDato &elemento)
{
bool res;
if(PilaVacia())//(cima == -1)
{cerr << "Se esta intentando quitar un elemento de una pila vacia (underflow)" << endl;
res = false;
}else

     { pila[cima];
cima--;
res = true;
}

return res;


}

bool Pila::PilaVacia()
{
return cima == -1;
}

void Pila::LimpiarPila()
{
cima = -1;
}


bool Pila::Iguales(Pila p)
{
TipoDato a , b;
TipoDato array[MAX];

bool iguales=false;

int i=cima;
while (p.CimaPila(b) && array[i--]==b)
{
    p.Desapilar();
}
if(i<0 && p.PilaVacia())
iguales=true;

return iguales;
}

/*************************************************************/
//                      pila.h
/*************************************************************/
#ifndef _PILA_H
#define _PILA_H

class Pila
{
   private:
           static const int MAX = 100;
           typedef int TipoDato;
           TipoDato pila[MAX];
           int cima;
        
   public:
          Pila();
          bool Apilar(TipoDato &elemento);
          bool Desapilar();
          bool CimaPila(TipoDato &elemento);
          void LimpiarPila();
          void VerPila();          
          bool PilaVacia();
          bool Iguales(Pila p);
   
};


#endif

Leer más…