Estructuras Pilas y Colas

Pilas Colas

Adicionar

Extraer
 Pilas
• Una pila es un tipo especial de lista simplemente enlazada
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", respectivamente “apilar" y
“desapilar".
• Estas características implican un comportamiento de lista
LIFO (Last In First Out), el último en entrar es el primero en
salir.
• Por ejemplo la pila de platos. Sólo es posible añadir platos
en la parte superior de la pila, y sólo pueden tomarse del
mismo extremo.

Push Pop
(apilar) (desapilar)
 Declaraciones de tipos para manejar pilas en C
• Los tipos que definiremos normalmente para manejar pilas serán casi los mismos que para
manejar listas, tan sólo cambiaremos algunos nombres:

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Pila;

• tipoNodo es el tipo para declarar nodos, evidentemente.

• pNodo es el tipo para declarar punteros a un nodo.
• Pila es el tipo para declarar pilas.

• Es evidente, a la vista del gráfico, que una pila es una lista simplemente enlazada. Así que sigue siendo muy
importante que nuestro programa nunca pierda el valor del puntero al primer elemento, igual que pasa con
las lista simplemente enlazada.
• Teniendo en cuenta que las inserciones y borrados en una pila se hacen siempre en un extremo, lo que
consideramos como el primer elemento de la lista es en realidad el último elemento de la pila.
 Operaciones básicas con pilas
• Las pilas tienen un conjunto de operaciones
muy limitado, sólo permiten las operaciones
de "push" y "pop":
• Push: Añadir un elemento al final de la pila.
• Pop: Leer y eliminar un elemento del final de
la pila.
 Las pilas
La pila es una estructura de datos que permite almacenar datos en el
orden LIFO (Last In First Out) en español, último en entrar, primero en
salir).
La recuperación de los datos es hecha en el orden inverso de su
inserción.

• Para la implementación he elegido una lista enlazada simple,

presentada sobre la vertical.
• Ya que la inserción 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 ha utilizado un puntero fin, ya que el objetivo no es el de
tratar una lista enlazada, sino una pila.
• Lo interesante es que el ultimo elemento ingresado, será el 1er
elemento recuperado.
 La construcción del modelo de un elemento de
la pila
• Para 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 puntero siguiente debe ser del mismo tipo que el elemento, de lo
contrario no podrá apuntar hacia el elemento.
• El puntero siguiente permitirá el acceso al próximo 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 1er elemento, que se encuentra en la cabeza de la pila, nos
permitirá realizar la operación de recuperación de los datos situados
en la parte superior de la pila.
Para ello, será utilizada otra estructura (no es obligatorio, pueden ser
utilizadas variables).
typedef struct ListaUbicación{
Elemento *inicio;
int tamaño;
} Pila;
El puntero inicio contendrá la dirección del 1er elemento de la lista.
La variable tamaño contiene el numero de elementos.
Nota:
Esta vez no utilizamos un puntero fin (ver la lista
enlazada simple), no lo necesitamos puesto que
únicamente trabajamos al inicio de la lista.
Cualquiera que sea la posición en la lista, el
puntero inicio apunta siempre hacia el 1er
elemento, que estará en la cabeza de la pila.
El campo tamaño contendrá el numero de
elementos de la pila, cualquiera que sea la
operación efectuada sobre la pila.
 Operaciones sobre las pilas
A. Inicialización
Modelo de la función:
void inicialización (Pila *tas);
Esta operación debe ser hecha antes de cualquier otra operación sobre la
pila.
Esta inicializa el puntero inicio con el puntero NULL, y el tamaño con el valor
0.
La función
void inicialización (Pila * tas){
tas->inicio = NULL;
tas->tamaño = 0;
}
 B. Inserción de un elemento en la pila
• A continuación el algoritmo de inserción y registro de
los elementos : declaración del elemento a insertar
• asignación 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 tamaño de la pila.

Modelo de la función:
int apilar (Pila *tas, char *dato);
La primera imagen muestra el inicio de la inserción, por lo tanto la lista de
tamaño 1 después de la inserción. La característica de la pila no es muy apreciada con un
solo elemento, ya que es el único a recuperar.
En cambio la 2da imagen nos permite observar el comportamiento de la pila.
Lo que debemos retener es que la inserción siempre se hace en la parte superior de la pila (al
inicio de la lista).
 C. Eliminar un elemento de la pila (POP)
• Para eliminar un elemento de la pila, simplemente hay que eliminar el elemento
hacia el cual apunta el puntero inicio.
Esta operación no permite recuperar el dato en la cabeza de la pila, solo
eliminarlo.
Modelo de la función:
int desapilar (Pila *tas);
La función devuelve -1 en caso de error, si no devuelve 0.
Las etapas:
• el puntero sup_elemento contendrá la dirección del 1er elemento
• el puntero inicio apuntará hacia el 2do elemento (después de la eliminación del
1er elemento, el 2do elemento estará en la cabeza de la pila)
• el tamaño de la pila disminuirá un elemento.
•
 Ejercicio
• Utilizando Estructura de datos tipo Pilas,
construir un algoritmo (aplicación en C++) que
permita describir el funcionamiento del juego
de la Torre de Hanoi
• Sólo aplicar el pop de toda la pila origen
• No puede colocarse un nodo con mayor valor
sobre otro de menor valor
• Mostrar los orígenes y resultados de las pilas
en cada paso
 Torres de Hanoi (práctica)

A B C

A B C
 Torres de Hanoi (práctica)
1

A B C
2

A B C
 Torres de Hanoi (práctica)
3

A B C
4

A B C
 Torres de Hanoi (práctica)
5

A B C
6

A B C
 Torres de Hanoi (práctica)
7

A B C
 Ejercicio
• Construir un Menu de Operaciones sobre Pilas
1. Push de un nuevo elemento
2. Pop de un elemento
3. Visualizar pila
4. Eliminar Pila
5. Salir
 Ejercicio 2
Una industria despacha cajas de frascos de mermelada, cada caja
contiene 12 frascos. Se trabajan en dos fases: envasado y distribución
• Fase de Envasado: Una persona coloca 12 frascos en la caja, la
cierra y la sella con cinta adhesiva; se van ordenando en torres de
máximo 20 cajas
• Otra persona, desde cada torre, va tomando las cajas de encima y
se van etiquetando, formando una nueva pila de cajas listas para su
despacho.
• Aplicando una estructura tipo PILA Elaborar un algoritmos que
describa dicho proceso
 Ejercicio 2
Una industria despacha cajas de frascos de mermelada, cada caja contiene 12 frascos. Se
trabajan en dos fases: envasado y distribución
• Fase de Envasado: Una persona coloca 12 frascos en la caja, la cierra y la sella con cinta
adhesiva; se van ordenando en torres de máximo 20 cajas
• Otra persona, desde cada torre, va tomando las cajas de encima y se van etiquetando,
formando una nueva pila de cajas listas para su despacho.
• Aplicando una estructura tipo PILA Elaborar un algoritmos que describa dicho proceso

• Insertar Nodos al inicio de la Pila

• Asignar un valor numérico para identifica cada nuevo nodo
• Debe permitir la inserción a un máximo de 20 cajas
• El ingreso del nuevo elemento debe ser continuo
1.- Apilar Cajas Selladas • Mostrar la nueva lista indicando el inicio

2.- Desempilar las Cajas y formar una nueva torre

3.- Mostrar las dos pilas • Cada desempilada debe mostrar la pila anterior y la nueva
pila
• La desempilada es un máximo de 20
• Mostrar la nueva pila indicando el inicio
 Colas
• Una cola es un tipo especial de lista abierta en la que
sólo se pueden insertar nodos en uno de los extremos
de la lista y sólo se pueden eliminar nodos en el otro.
Además, como sucede con las pilas, las escrituras de
datos siempre son inserciones de nodos, y las lecturas
siempre eliminan el nodo leído.
• Este tipo de lista es conocido como lista FIFO (First In
First Out), el primero en entrar es el primero en salir.
• El símil cotidiano es una cola para comprar, por
ejemplo, las entradas del cine. Los nuevos
compradores sólo pueden colocarse al final de la cola,
y sólo el primero de la cola puede comprar la entrada.
 Declaraciones de tipos para manejar colas en C
• Los tipos que definiremos normalmente para manejar colas serán casi los mismos que para manejar listas y pilas, tan sólo
cambiaremos algunos nombres:
typedef struct _nodo {
int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Cola;

• tipoNodo es el tipo para declarar nodos, evidentemente.

• pNodo es el tipo para declarar punteros a un nodo.
• Cola es el tipo para declarar colas.

• Una cola es una lista abierta. No se debe perder el valor del puntero al primer elemento, igual que pasa con las listas
abiertas. Además, debido al funcionamiento de las colas, también deberemos mantener un puntero para el último elemento
de la cola, que será el punto donde insertemos nuevos nodos.
• Teniendo en cuenta que las lecturas y escrituras en una cola se hacen siempre en extremos distintos, lo más fácil será
insertar nodos por el final,.
 Operaciones básicas con colas
Nos encontramos ante una estructura con muy
pocas operaciones disponibles. Las colas sólo
permiten añadir y leer elementos:
• Añadir: Inserta un elemento al final de la cola.
• Leer: Lee y elimina un elemento del principio
de la cola.
Añadir elemento en una cola vacía
Partiremos de que ya tenemos el nodo a insertar y, por
supuesto un puntero que apunte a él, además los punteros
que definen la cola, primero y ultimo que valdrán NULL:

El proceso es muy simple, bastará con que:

1. Hacer que nodo->siguiente apunte a NULL.
2. Que el puntero primero apunte a nodo.
3. Y que el puntero último también apunte a nodo.
Añadir elemento en una cola, caso general
• Para generalizar el caso anterior, sólo se requiere añadir una
operación:
1. Hacemos que nodo->siguiente apunte a NULL.
2. Si ultimo no es NULL, hacemos que ultimo->siguiente apunte a
nodo.
3. Y actualizamos ultimo, haciendo que apunte a nodo.
4. Si primero es NULL, significa que la cola estaba vacía, así que
haremos que primero apunte también a nodo.
 Ejercicio Colas
• Construir un Menu de Operaciones sobre Colas
1. Adiciona nuevos elementos
2. Atender elementos de la cola
3. Cambiar la prioridad de atención a un elemento
especifico
4. Eliminar Cola
5. Salir
En cada caso mostrar la cola inicial y la resultante