[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…

[Codigo Fuente] Ejercicio 3 UT9

//#================================================================
//#Nombre:
//#Autor: Ernesto Lezcano
//#Descripcion:
//#================================================================
//# -------------------------[C O D E]-----------------------------
//#================================================================
#include <iostream>

const int TAM=50;

class Pila
{
    public:
           typedef int Valor;
           Pila();
           //Pila(Pila x);

             bool Apilar(Valor);
           bool Desapilar();
           bool CimaPila(Valor &);
           bool PilaVacia();
           //void MostrarPila(void);
             bool Primeros(int x, Pila p1);
           bool Ultimos(int x, Pila p1);
    private:
            int cima;
            Valor v[TAM];
};

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

//#================================================================
//# -----------------------[Constructor]---------------------------
//#================================================================

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

//#================================================================
//# --------------------------[Apilar]-----------------------------
//#================================================================

bool Pila::Apilar(Valor num)
{
  bool apila;

  if (cima == TAM)
  {
      apila=false;
  }
  else

    {
      cima++;
      v[cima]=num;
      apila=true;
  }

  return apila;
}

//#================================================================
//# ------------------------[Desapilar]----------------------------
//#================================================================

bool Pila::Desapilar()
{
   bool desapila;
 
   if (cima==-1)
   {
       desapila=false;
   }
   else

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

//#================================================================
//# -------------------------[CimaPila]----------------------------
//#================================================================

bool Pila::CimaPila(Valor &num)
{
   bool cimapila;
 
   if (PilaVacia())
   {
       cimapila=false;
   }
   else

     {
       cimapila=true;
       num=v[cima];
   }
 
   return cimapila;
}

//#================================================================
//# -------------------------[PilaVacia]---------------------------
//#================================================================

bool Pila::PilaVacia()
{
   return (cima == -1);
}
/*
//#================================================================
//# -----------------------[MostrarPila]---------------------------
//#================================================================

void Pila::MostrarPila()
{
   for (int i=0; i<=cima; i++)
   {
       cout << v[i] << endl;
   }
}
*/

//#================================================================
//# ---------------------[SubPilaPrimeros]-------------------------
//#================================================================


bool Pila::Primeros(int x, Pila p1)
{  
   int i;
   bool primero=false;
 
   if (!p1.PilaVacia())
   {
       for (i=0; i<x && i<p1.cima; i++)
           v[i]=p1.v[i];
       cima=x-1;
       primero=true;
   }
 
   return primero;
}


//#================================================================
//# ---------------------[SubPilaUltimos]--------------------------
//#================================================================

bool Pila::Ultimos(int x, Pila p1)
{
   int i;
   bool ultimo=false;
 
   if(!p1.PilaVacia()&&x<p1.cima)
   {
       for (i=p1.cima-x; i<p1.cima; i++)
       {
           v[i-x]=p1.v[i];
           cout << v[i-x]<<endl;
       }
       cima=x-1;
       ultimo=true;
   }
 
   return ultimo;
}

Leer más…

Colas

Fundamentos:

Las colas son una estructura de datos similar a las pilas, pero en las colas se insertan elementos por un extremo y se retiran elementos por el otro extremo.

Una cola se puede representar como la cola del PCBOX. Entra “A” a la tienda y se pone el primero de la cola despues entra "B" y asi hasta "K", el primero en ser atendido es "A", después "B" y asi hasta "K". La cola es como un tubo que entran por la izquierda y salen por la derecha.

La cola a diferencia de la pila tiene una estructura lineal de tipo “FIFO” (First input Firt Output) Primero en entrar, primero en salir.

Una cola puede estar vacia (sin ningun elemento) o llena (En el caso que tengamos un tamaño fijo (Vector)).

Especificacion de una cola:

Estas son las especificaciones de una clase "Cola":

• Tipo de Dato: Dato que se almacenara en la cola.
• Insertar: Insertar un elemento a la cola.
  
• Eliminar: Eliminar un elemento de la cola.
  
• BorrarCola: Borrar la cola.
  
• Frente: Acceso a la cola.

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…

Pilas

Fundamentos:

Una lista de elementos caracterizada porque las operaciones de insercion y extraccion de elementos se realiza solamente en un extremo de la estructura (cima).

Una pila se puede representar como un tubo de pastillas. “a” esta en el fondo de la pila y es la mas inaccesible y “k” la primera accesible.

La pila tiene una estructura lineal de tipo “LIFO” (Last input Firt Output).

Una pila puede estar vacia (sin ningun elemento) o llena (En el caso que tengamos un tamaño fijo (Vector)).

Si un programa intenta sacar un elemento de una pila vacia se produce un desbordamiento negativo (underflow) y si la pila esta llena y se quiere añadir un elemento más se produce un desbordamiento (overflow).

Especificacion de una pila:

Estas son las especificaciones de una clase "Pila":

• Tipo de Dato: Dato que se almacenara en la pila.
• Apilar (push): Insertar un dato de pila.
  
• Desapilar (pop): Resta 1 a cima.
  
• CimaPila:
  
• Pila vacia: Comprueba si esta vacia.
  
• Pila llena: Comprueba si esta llena.
  
• Limpiar Pila: Pone cima a cero.
  

Leer más…

Estructuras de datos dinámicas

Existen dos tipos de estructuras de datos dinámicas:

• Lineales: Pilas, Colas, Listas.
• No lineales: Arboles, Grafos.
  

Leer más…