Rechercher

RegistrarseConexin

TrucosProgramacinLenguajesLenguaje C

Las pilas en lenguaje CMarzo 2015

Las pilas

RequisitosIntroduccinDefinicinLa elaboracin del modelo de un elemento de la pilaOperaciones sobre las pilas

InicializacinInsercin de un elemento en la pilaEliminar un elemento de la pilaVisualizacin de la pilaRecuperacin del dato en la cabeza de la pila

Ejemplo completopila.hpila_function.hpila.c

Saber ms

RequisitosLos requisitos son los tipos de datos, las estructuras, el uso de typedef, los punteros, las funciones de usuario, las listas simplemente enlazadas, las listasdoblemente enlazadas.

IntroduccinEl objetivo de este artculo es que el lector entienda el empleo de las pilas. Para explicar el algoritmo he escogido utilizar una lista enlazada simple. Por lotanto la comprensin de las listas enlazadas es necesaria.

Recherche

DefinicinLa pila es una estructura de datos que permite almacenar datos en el orden LIFO (Last In First Out, en espaol, "ltimo en entrar, primero en salir"). Larecuperacin de los datos es realizada en el orden inverso de su insercin. Para la implementacin he elegido una lista enlazada simple, presentada sobrela vertical. Ya que la insercin es siempre hecha al inicio de la lista, el primer elemento de la lista ser el ultimo elemento ingresado, por lo tanto estar en lacabeza de la pila. No he utilizado un puntero fin, como lo hice en el caso de la lista enlazada simple, ya que el objetivo no es el de tratar una lista enlazada,sino una pila. Lo interesante es que el ltimo elemento ingresado, ser el primer elemento recuperado.

La elaboracin del modelo de un elemento de la pilaPara definir un elemento de la pila ser utilizado el tipo struct. El elemento de la pila contendr un campo dato y un puntero siguiente. El punterosiguiente tiene que ser de la misma clase que el elemento, de lo contrario no va a poder apuntar hacia el elemento. El puntero siguiente permitir elacceso al prximo elemento.typedef struct ElementoLista { char *dato; struct ElementoLista *siguiente;}Elemento;Para permitir las operaciones sobre la pila, vamos a guardar ciertos elementos: el primer elemento, el numero de elementos El primer elemento, que seencuentra en la cabeza de la pila, nos permitir realizar la operacin de recuperacin de los datos situados en la parte superior de la pila. Para ello, seutilizar otra estructura (no es obligatorio, pueden ser utilizadas variables).typedef struct ListaUbicacin{ Elemento *inicio; int tamao;} Pila;El puntero inicio inidicar la direccin del primer elemento de la lista. La variable tamao contiene el numero de elementos. Nota: Esta vez no utilizamosun puntero fin (ver la lista enlazada simple), no lo necesitamos puesto que nicamente trabajamos al inicio de la lista. Cualquiera que sea la posicin en lalista, el puntero inicio apunta siempre hacia el primer elemento, que estar en la cabeza de la pila. El campo tamao abarcar el numero de elementos dela pila, cualquiera que sea la operacin efectuada sobre la pila.

Operaciones sobre las pilas

InicializacinModelo de la funcin:void inicializacin (Pila *tas);Esta operacin debe ser realizada antes de cualquier otra operacin sobre la pila. Esta inicializa el puntero inicio con el puntero NULL y el tamao con elvalor 0. La funcinvoid inicializacin (Pila * tas){ tas->inicio = NULL; tas->tamao = 0;}

Insercin de un elemento en la pilaA continuacin, veremos el algoritmo de insercin y el registro de los elementos: declaracin del elemento que va a insertarse, asignacin de la memoriapara el siguiente elemento, introducir el contenido del campo de los datos, actualizar el puntero inicio hacia el primer elemento (la cabeza de la pila).Actualizar el tamao de la pila. Modelo de la funcin:int apilar (Pila *tas, char *dato);La primera imagen muestra el comienzo de la insercin, por lo tanto la lista de tamao 1 despus de la insercin. La caracterstica de la pila no es muyapreciada con un solo elemento, ya que es el nico a recuperar.

En cambio la segunda imagen nos permite observar el comportamiento de la pila. Lo que debemos retener es que la insercin siempre se hace en la partesuperior de la pila (al inicio de la lista).

La funcin/* apilar (aadir) un elemento en la pila */int apilar (Pila * tas, char *dato){ Elemento *nuevo_elemento; if ((nuevo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL) return -1; if ((nuevo_elemento->dato = (char *) malloc (50 * sizeof (char)))

Eliminar un elemento de la pilaPara eliminar un elemento de la pila, simplemente hay que eliminar el elemento hacia el cual apunta el puntero inicio. Esta operacin no permite recuperarel dato en la cabeza de la pila, solo eliminarlo. Modelo de la funcin:int desapilar (Pila *tas);La funcin da como resultado -1 en caso de error, si no devuelve 0. Las etapas: El puntero sup_elemento contendr la direccin del primer elemento. Elpuntero inicio apuntar hacia el segundo elemento (despus de la eliminacin del primer elemento, el segundo elemento estar en la cabeza de la pila). Eltamao de la pila disminuir un elemento.

La funcinint desapilar (Pila * tas){ Elemento *sup_elemento; if (tas->tamao == 0) return -1; sup_elemento = tas->inicio; tas->inicio = tas->inicio->siguiente; free (sup_elemento->dato); free (sup_elemento);

Visualizacin de la pila

Para mostrar la pila entera, es necesario posicionarse al inicio de la pila (el puntero inicio lo permitir). Luego, utilizando el puntero siguiente de cadaelemento, la pila es recorrida del primero hacia el ultimo elemento. La condicin para detenerse es determinada por el tamao de la pila. La funcin/* visualizacin de la pila */void muestra (Pila * tas){ Elemento *actual; int i; actual = tas->inicio; for(i=0;itamao;++i){ printf("\t\t%s\n", actual->dato); actual = actual->siguiente; }

Recuperacin del dato en la cabeza de la pilaPara recuperar el dato en la cabeza de la pila sin eliminarlo, he utilizado una macro. La macro lee los datos en la parte superior de la pila utilizando elpuntero inicio.#define pila_dato(tas) tas->inicio->dato

Ejemplo completo

pila.h/*********************\

pila.h *\*********************/typedef struct ElementoLista{ char *dato; struct ElementoLista *siguiente;} Elemento;typedef struct ListaUbicacin{ Elemento *inicio; int tamao;} Pila;/* inicializacin */void inicializacin (Pila *tas);/* APILAR*/int apilar (Pile *tas, char *dato);/* DESAPILAR*/int desapilar (Pila *tas);/* Visualizacin del elemento en la cabeza de la pila (LastInFirstOut) */#define pila_dato(tas) tas->inicio->dato/* muestra la pila */void muestra (Pila *tas);

pila_function.h/***********************\

pila_function.h *\***********************/void inicializacin (Pila * tas){ tas->inicio = NULL; tas->tamao = 0;}/* apilar (aadir) un elemento en la pila */int apilar (Pila * tas, char *dato){ Elemento *nuevo_elemento; if ((nuevo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL) return -1; if ((nuevo_elemento->dato = (char *) malloc (50 * sizeof (char))) == NULL) return -1; strcpy (nuevo_elemento->dato, dato); nuevo_elemento->siguiente = tas->inicio; tas->inicio = nuevo_elemento; tas->tamao++;}/* desapilar (eliminar un elemento de la pila */int desapilar (Pila * tas){ Elemento *sup_elemento; if (tas->tamao == 0) return -1; sup_elemento = tas->inicio; tas->inicio = tas->inicio->siguiente; free (sup_elemento->dato); free (sup_elemento); tas->tamao--; return 0;}/* visualizacin de la pila */void muestra (Pila * tas){ Elemento *actual; int i; actual = tas->inicio; for(i=0;itamao;++i){ printf("\t\t%s\n", actual->dato); actual = actual->siguiente; }}

pila.c/*********************\

pila.c *\*********************/#include#include#include#include "pila.h"#include "pila_function.h"int main (){ Pila *tas; char *nom; if ((tas = (Pila *) malloc (sizeof (Pila))) == NULL) return -1; if ((nom = (char *) malloc (50 * sizeof (char))) == NULL) return -1; inicializacin (tas); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("\nLa ultima entrada (LastInFirstOut) [ %s ] sera eliminada", pile_dato(tas)); printf ("\nLa ultima entrada es eliminada\n"); desapilar (tas); /* eliminacin del ultimo elemento ingresado */ printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); return 0;}

Saber msLas listas enlazadas simples Las listas doblemente enlazadasEl documento Las pilas en lenguaje C de Kioskea (es.kioskea.net) se encuentra disponible bajo una licencia Creative Commons. Puedes copiarlo o modificarlo bajo las condicionessealadas por esta licencia. Debers hacerla siempre visible y dar crdito a Kioskea.