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:


15 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?

  1. Anónimo dijo...:

    genial gracias :D

Publicar un comentario en la entrada

Tienes alguna duda? , comenta aqui :)

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