Buscar en el Blog

martes, 26 de enero de 2016

Pilas C++

Una pila es un tipo especial de lista en la que sólo se pueden insertar y eliminar nodos en uno de los extremos de la lista. Estas operaciones se conocen como "push" y "pop",
Estas características implican un comportamiento de lista LIFO (Last In First Out), el último en entrar es el primero en salir.
 




  Estructura Nodo.


typedef struct _nodo
{
    int valor;
    struct _nodo *siguiente;
}tiponodo;
 
 
la variable valor es la razon de ser de la estructura(nodo). 
Aqui se almacena el valor del nodo.

struct _nodo sirve para almacenar la direccion del siguiente nodo. Al inicio este 
valor el nulo.


typedef tiponodo *pNodo; Nodo para poder crear los nuevos nodos.
typedef tiponodo *cima; Sirve para almacenar el nodo que esta en la cima de todos
los elementos. 

 Funciones

Push(Insertar)
 En las lineas

    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
 
Se crea un nodo con valores nulos.
 
 

En la linea nuevoNodo->valor=valor;
Aqui recien se esta almacenando un valor a la variable "valor". Ejemplo el numero 10.

En  nuevoNodo->siguiente=*l;

El nuevo nodo apunto a la direccion de memoria del elemento que estaba en la cima. Si es este "nuevo nodo" el primero elemento y como cima al iniciar es nulo, entonces "siguente"  almacenará NULL.


En  *l=nuevoNodo;

Aqui decimos que el nuevo nodo es la nueva cima.  




 void Push(cima *l, int valor)
{
    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
    nuevoNodo->valor=valor;
    /*Añadimos la cima a la continuacion del nuevo nodo*/
    nuevoNodo->siguiente=*l;
    *l=nuevoNodo;
}






Esto pasa si es el primero elemento. Caso contrario en lugar de apuntar a null, el nuevo elemento y/o la cima  apuntaria al elemento anterior.





Ahora el Pop
Para el eliminar un elemento de la pila, simplemente obtenemos el elemento siguiente de la pila y hacemos q cima apunto a ese siguiente elemento. En cuanto al elemento que estaba en la cima(el elemento a eliminar), simplemente se libera de la memoria.










int Pop(cima *l)
{
    pNodo nodo;//variable auxiliar
    int r;
    nodo=*l;//apuntando el primer elemento de la cima;
    if(!nodo) return 0;
    *l=nodo->siguiente;
    r=nodo->valor;
    free(nodo);//libera la memoria
    return r;
}
 
 

Codigo Completo



#include <iostream>

using namespace std;
typedef struct _nodo
{
    int valor;
    struct _nodo *siguiente;
}tiponodo;
typedef tiponodo *pNodo;
typedef tiponodo *cima;

/*Protipos de funciones con las cimas*/
void Push(cima *l ,int valor);
int Pop(cima *l);
int main()
{

    cima micima=NULL;
    Push(&micima,10);
    Push(&micima,20);
    Push(&micima,30);


 
      cout<<Pop($micima);
      cout<<Pop($micima);
      cout<<Pop($micima); 

    return 0;
}

void Push(cima *l, int valor)
{
    pNodo nuevoNodo;//declarando
    /*creando*/
    nuevoNodo=(pNodo)malloc(sizeof(tiponodo ));
    nuevoNodo->valor=valor;
    /*Añadimos la cima a la continuacion del nuevo nodo*/
    nuevoNodo->siguiente=*l;
    *l=nuevoNodo;
}

int Pop(cima *l)
{
    pNodo nodo;//variable auxiliar
    int r;
    nodo=*l;//apuntando el primer elemento de la cima;
    if(!nodo) return 0;
    *l=nodo->siguiente;
    r=nodo->valor;
    free(nodo);
    return r;


}

No hay comentarios:

Publicar un comentario