Pilas en C++


Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.


Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.


Implementacion en C++

/*
  Name: Pilas
  Copyright: casicodigo.blogspot.com
  Author: Jose Martin Cruz Otiniano
  Date: 27/10/12 12:27
  Description: Apila elemento, Desempila elemento, Mostrar pila, Destruir Pila
*/
 
#include <iostream>
using namespace std;
 
struct nodo{
    int nro;
    struct nodo *sgte;
};
 
typedef nodo *ptrPila;   // creando nodo tipo puntero( tipo de dato )
 
/*                        Apilar elemento      
---------------------------------------------------------------------*/
void push( ptrPila &p, int valor )
{
     ptrPila aux;
     aux = new(struct nodo);  // apuntamos al nuevo nodo creado
     aux->nro = valor;
     
     aux->sgte = p ;
     p = aux ;
}
 
/*                Desapilar elemento(devuelve elemento)      
---------------------------------------------------------------------*/
int pop( ptrPila &p )
{
     int num ;
     ptrPila aux;
     
     aux = p ;
     num = aux->nro;   // asignamos el primer vamor de la pila
     
     p = aux->sgte ;
     delete(aux);
     
     return num;
}
 
/*                     Muestra elementos de la pila      
---------------------------------------------------------------------*/
void mostrar_pila( ptrPila p )
{
     ptrPila aux;
     aux = p;     // apunta al inicio de la lista
     
     while( aux !=NULL )
     {
            cout<<"\t"<< aux->nro <<endl;
            aux = aux->sgte;
     }    
}
 
/*                Eliminar todos los elementos de la pila      
---------------------------------------------------------------------*/
void destruir_pila( ptrPila &p)
{
     ptrPila aux;
     
     while( p != NULL)
     {
           aux = p;
           p = aux->sgte;
           delete(aux);
     }
}
 
/*                        Menu de opciones    
----------------------------------------------------------------------*/
void menu()
{
    cout<<"\n\t IMPLEMENTACION DE PILAS EN C++\n\n";
    cout<<" 1. APILAR                                "<<endl;
    cout<<" 2. DESAPILAR                             "<<endl;
    cout<<" 3. MOSTRAR PILA                          "<<endl;
    cout<<" 4. DESTRUIR PILA                         "<<endl;
    cout<<" 5. SALIR                                 "<<endl;
 
    cout<<"\n INGRESE OPCION: ";
}
 
/*                        Funcion Principal        
----------------------------------------------------------------------*/
int main()
{
    ptrPila p = NULL;  // creando pila
    int dato;
    int op;
    int x ; // numero que devuelve la funcon pop
   
    system("color 0b");
 
    do
    {
        menu();  cin>> op;
 
        switch(op)
        {
            case 1:
 
                 cout<< "\n NUMERO A APILAR: "; cin>> dato;
                 push( p, dato );
                 cout<<"\n\n\t\tNumero " << dato << " apilado...\n\n";
            break;
 
 
            case 2:
 
                 x = pop( p );
                 cout<<"\n\n\t\tNumero "<< x <<" desapilado...\n\n";
            break;
                 
 
            case 3:
 
                 cout << "\n\n MOSTRANDO PILA\n\n";
                 if(p!=NULL)
                    mostrar_pila( p );
                 else
                    cout<<"\n\n\tPila vacia..!"<<endl;
            break;
 
 
            case 4:
 
                 destruir_pila( p );
                 cout<<"\n\n\t\tPila eliminada...\n\n";
            break;
           
         }
 
        cout<<endl<<endl;
        system("pause");  system("cls");
 
    }while(op!=5);
   
   
    return 0;
}

Sigueme en facebook y dejame un comentario, agradecer no cuesta nada :D
PD: Si deseas copiar el codigo esta en este enlace. 

Tambien te puede interesar:


14 comentarios:

  1. Anónimo dijo...:

    busco el codigo de las torres de hanoi

  1. Martin Cruz dijo...:

    Ahi tienes el link espero que te sirva:

    http://casicodigo.blogspot.com/2012/09/resursividad-torres-de-hanoi-en-c.html

  1. Eli_Pache dijo...:

    muuuy bueno!!! gracias!

  1. juan rodriguez dijo...:

    amigo me podrias agregar mas comentarios? diciendo que hace cada funcion?

  1. Anónimo dijo...:

    Esta chido, llevo 3 días estudiandolo, ya casi lo entiendo todo! XD

  1. Diana Rojas dijo...:

    excelente programa pero no entiendo que esta haciendo cuando agrega este codigo
    " struct nodo *sgte;"

    gracias!

  1. Martin Cruz dijo...:

    Hola Diana Rojas, respondiendo a tu pregunta vamos por partes. El *sgte el nombre de un puntero por eso lleva asterisco, ahora el struct nodo, es el tipo de dato del puntero. Y te preguntaras para que? pues es para apuntar a un dato(nodo) llamado 'struct nodo' que es del mismo tipo(struct nodo{};) ... Saludos

    PD: Un puntero siempre debe apuntar a una variable que es del mismo tipo del mismo.

  1. Anónimo dijo...:

    ESTA CHIDO Q BIEN

  1. Anónimo dijo...:

    al momento de imprimir los numeros como puedo imprimir tambien nombres

  1. Jose dijo...:

    Muy buena estructura... y muy claro te felicito..!

  1. Anónimo dijo...:

    El codigo esta muy bien explicado, muchas gracias por fin entendi, solo que lo que aun no entiendo es cuando la pila tiene un X tamaño el cual te de un limite para ingresar elementos a la pila
    en ese caso como seria el codigo?

  1. plastigel dijo...:

    hola tengo una duda que hace este signo ->?

  1. Gracias, como puedo hacerlo en codigo en C?

  1. Disculpa siguiendo tu código como sería para eliminar los elementos repetidos de una pila?

Publicar un comentario en la entrada

Tienes alguna duda? , comenta aqui :)

 
Copyrigth © 2012 Casi Codigo | Diseñado por Casi Codigo