I.

INTRODUCCIN
El objetivo es comprender el empleo de las pilas.

II. Definicin
La pila es una estructura de datos que los almacena en el orden LIFO (Last In First Out) en espaol, (ltimo en entrar, primero en salir). La recuperacin de los datos es hecha en el orden inverso a su insercin. Ya que la insercin es siempre hecha al inicio de la lista, el 1er elemento de la lista ser el ultimo elemento ingresado, por lo tanto estar en la cabeza de la pila. No se utiliza un puntero fin, ya que el objetivo es tratar con una pila. Lo interesante es que el ltimo elemento ingresado, ser el 1er elemento recuperado.

Figura 1: La pila

III. La construccin del modelo de un elemento de la pila

Para definir un elemento de la pila utilizamos el tipo struct. El elemento de la pila contendr un campo dato y un puntero siguiente. El puntero siguiente es del mismo tipo que el elemento, de lo contrario no apuntar hacia l. El puntero siguiente accede al prximo elemento.

typedef struct ElementoLista { char *dato; struct ElementoLista *siguiente; }Elemento; Para las operaciones sobre la pila, vamos a guardar ciertos elementos: el primer elemento el nmero de elementos El 1er elemento, que se encuentra en la cabeza de la pila, realiza la operacin de recuperacin de los datos situados en la parte superior de la pila. Para ello, utilizamos otra estructura, aunque no es obligatorio, puede utilizar variables. typedef struct ListaUbicacin{ Elemento *inicio; int tamao; } Pila; El puntero inicio contendr la direccin del 1er elemento de la lista. La variable tamao contiene el nmero de elementos. Cualquiera que sea su posicin en la lista, el puntero inicio apunta siempre hacia el 1er elemento, que est en la cabeza de la pila. El campo tamao contendr el nmero de elementos de la pila, cualquiera que sea la operacin efectuada sobre dicha pila.

IV. Operaciones sobre las pilas

A. Inicializacin
Modelo de la funcin: void inicializacin (Pila *tas); Esta operacin debe ser realizada antes que cualquier otra operacin sobre la pila. Esta operacin inicializa el puntero inicio con el puntero NULL, y el tamao con el valor 0. Vea la siguiente funcin:
void inicializacin (Pila * tas){ tas->inicio = NULL; tas->tamao = 0; }

B. Insercin de un elemento en la pila

A continuacin, se presenta el algoritmo de insercin y registro de los elementos: declaracin del elemento a insertar asignacin de la memoria para el nuevo elemento rellenar el contenido del campo de datos

 actualizar el puntero inicio hacia el 1er elemento (la cabeza de la pila) Actualizar el tamao de la pila. Modelo de la funcin: int apilar (Pila *tas, char *dato); La primera figura muestra el inicio de la insercin, por lo tanto el tamao es 1 despus de la insercin. La caracterstica de la pila no es muy relevante con un slo elemento, ya que es el nico a recuperar.

Figura 2: Insercin en pila vaca En cambio en la 2da figura observamos el comportamiento de la pila. Lo que debemos retener es que la insercin siempre se hace en la parte superior de la pila (al inicio de la lista).

Figura 3: Insercin en pila 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))) == NULL) return -1; strcpy (nuevo_elemento->dato, dato); nuevo_elemento->siguiente = tas->inicio; tas->inicio = nuevo_elemento; tas->tamao++; }

C. Eliminar un elemento de la pila

Para eliminar un elemento de la pila, simplemente hay que eliminar el elemento al que apunta el puntero inicio. Esta operacin no recupera el dato en la cabeza de la pila, slo lo elimina. Modelo de la funcin:

int desapilar (Pila *tas); La funcin devuelve -1 en caso de error, si no devuelve 0. Las etapas: el puntero sup_elemento contendr la direccin del 1er elemento. el puntero inicio apuntar hacia el 2do elemento (despus de la eliminacin del 1er elemento, el 2do elemento estar en la cabeza de la pila) . el tamao de la pila disminuir un elemento.

Figura 4: Eliminar elemento o nodo de la pila

La funcin
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; }

D. 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 cada elemento, la pila es recorrida del 1er hacia el ultimo elemento. La condicin para detenerse es dada 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;i<tas->tamao;++i){ printf("\t\t%s\n", actual->dato); actual = actual->siguiente; } }

E. Recuperacin del dato en la cabeza de la pila

Para 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 el puntero inicio.
#define pila_dato(tas) tas->inicio->dato

V. 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;i<tas->tamao;++i){ printf("\t\t%s\n", actual->dato); actual = actual->siguiente; }

pila.c
/*********************\ * pila.c * \*********************/ #include<stdio.h> #include<stdlib.h> #include<string.h> #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; }

Ejercicio Explicar el subalgoritmo funcin recursiva de la funcin de Ackermann. Problema La pila es visualizada ya sea creciente de abajo hacia arriba (como pilas del mundo real), o, con el mximo elemento de la pila en una posicin fija, o creciente, de izquierda a derecha, por lo que el mximo elemento se convierte en el mximo a "la derecha". Esta visualizacin puede ser independiente de la estructura real de la pila en la memoria. Esto significa que rotar a la derecha es mover el primer elemento a la tercera posicin, la segunda a la primera y la tercera a la segunda. Aqu hay dos equivalentes visualizaciones de este proceso:
Manzana Pltano Fresa o simplemente, Fresa Manzana ==rotar a la derecha==> Pltano Fresa Manzana

Pltano Manzana

==rotar a la izquierda==>

Fresa Pltano

Escriba el programa C se ejecute la tarea de rotacin de los elementos de una pila.