Programación.

Tema 4: Pilas y Colas (16/Mayo/2004)

Apuntes elaborados por: Eduardo Quevedo, Raquel López y Aaron Asencio

Revisado por: Javier Miranda el ????

Tema 4.- Pilas y Colas

Las pilas y colas son estructuras de datos que se utilizan generalmente
para simplificar ciertas operaciones de programación.
Estas estructuras pueden implementarse mediante arrays o mediante
listas enlazadas.

Pilas:
Las pilas son estructuras de datos que tienes dos operaciones básicas:
push (para insertar un elemento) y pop (para extraer un elemento). Su
característica fundamental es que al extraer se obtiene siempre el último
elemento que acaba de insertarse. Por esta razón también se conocen como
estructuras de datos LIFO (del inglés Last In First Out). Una posible
implementación mediante listas enlazadas sería insertando y extrayendo
siempre por el principio de la lista. Gracias a las pilas es posible el uso de la
recursividad (lo veremos en detalle en el tema siguiente). La variable que llama
al mismo procedimiento en el q está, habrá que guardarla así como el resto de
variables de la nueva llamada, para a la vuelta de la recursividad ir sacandolas,
esto es posible a la implementación de pilas.

Las pilas se utilizan en muchas aplicaciones que utilizamos con

frecuencia. Por ejemplo, la gestión de ventanas en Windows (cuando cerramos
una ventana siempre recuperamos la que teníamos detrás). Otro ejemplo es la
evaluación general de cualquier expresión matemática para evitar tener que
calcular el número de variables temporales que hacen falta. Por ejemplo:

3 + 4 * (8 – 2 * 5)

5
-2 -10
8 8 -2
4 4 4 -8
3 3 3 3 -5

1
Programación. Tema 4: Pilas y Colas (16/Mayo/2004)

Colas:
Las colas también son llamadas FIFO (First In First Out), que quiere
decir “el primero que entra es el primero que sale”.

Colas simples:

Se inserta por un sitio y se saca por otro, en el caso de la cola simple se

inserta por el final y se saca por el principio. Para gestionar este tipo de cola
hay que recordar siempre cual es el siguiente elemento que se va a leer y cual
es el último elemento que se ha introducido.

910
973
175
137

Colas circulares:

En las colas circulares se considera que después del último elemento se

accede de nuevo al primero. De esta forma se reutilizan las posiciones
extraídas, el final de la cola es a su vez el principio, creándose un circuito
cerrado.

5 5 5
4 4 4 4
3 3 3 3
2 2 2 2
1 1 8

Lo que se ha hecho es insertar (5), sacar (1), e insertar (8).

Se sabrá que una tabla está llena cuando “rear” y “front” estén en una
posición de diferencia.

El teclado de ordenador se comporta exactamente como una cola

circular.

Para implementar las colas circulares mediante listas enlazadas se pone

en el tipo T_Lista los punteros front y rear.

2
Programación. Tema 4: Pilas y Colas (16/Mayo/2004)

Colas con prioridad:

Las colas con prioridad se implementan mediante listas o arrays
ordenados. No nos interesa en este caso que salgan en el orden de entrada
sino con una prioridad que le asignemos. Puede darse el caso que existan
varios elementos con la misma prioridad, en este caso saldrá primero aquel
que primero llego (FIFO).

Paquete Pila:

Finalmente implementamos el paquete pila tanto para un array como para

listas. Esta implementación será realmente útil para el tema siguiente,
recursividad.

Array:

ADS
generic type TDato is private;
package Pila_generica is

type TPila (Maximo : Positive) is private;

Llena, Vacia, FueraDeRango : exception;

procedure Push ( Pila : in out TPila; Dato : in TDato );

procedure Pop ( Pila : in out TPila; Dato: out TDato );
function PilaVacia (Pila : in TPila) return Boolean;
function PilaLlena (Pila : in TPila) return Boolean;
function Valor ( Pila : in TPila; Index : Positive ) return TDato;

private

type TVector is array (Positive range <>) of TDato;

type TPila (Maximo : Positive) is record
Contenido : TVector (1 .. Maximo);
Cima : Natural := 0;
end record;
end;

ADB
with Text_IO;
with Unchecked_Deallocation;
use Text_IO;

package body Pila_Generica_Dinamica is

procedure Free is new Unchecked_Deallocation

(TNodo,TPuntero);

3
Programación. Tema 4: Pilas y Colas (16/Mayo/2004)

function Vacia (Pila : in TPila) return Boolean is

begin
return Pila.Cab = null;
end;

procedure Push (Pila: in out TPila; Dato: in TDato) is

NuevoNodo : TPuntero := new TNodo;
begin
NuevoNodo.Dato := Dato;
NuevoNodo.Sig := Pila.Cab;
Pila.Cab := NuevoNodo;
Pila.Vacia := False;
end;

procedure Pop ( Pila : in out TPila; Dato : out TDato) is

P : TPuntero;
begin
if Pila.Vacia = True then
raise Vacia;
end if;
P := Pila.Cab;
Pila.Cab := Pila.Cab.Sig;
P.Sig := null;
Dato := P.Dato;
Free(P);
if Pila.Cab = null then
Pila.Vacia := True;
else
Pila.Vacia := False;
end if;
end;

procedure Reset (Pila : in out TPila) is

P : TPuntero;
begin
while Pila.Cab /= null loop
P := Pila.Cab;
Pila.Cab := Pila.Cab.Sig;
P.Sig := null;
Free (P);
end loop;
Pila.Vacia := True;
end;

end;

4
Programación. Tema 4: Pilas y Colas (16/Mayo/2004)

Listas:

ADS
generic type TDato is private;

package Pila_Generica_Dinamica is

type TPila is private;

Vacia : Exception;

function Vacia (Pila : in TPila) return Boolean;

procedure Reset (Pila : in out TPila);
procedure Push (Pila : in out TPila; Dato : in TDato);
procedure Pop (Pila : in out TPila; Dato : out TDato);

private

Type TNodo;

Type TPuntero is access TNodo;

Type TNodo is record

Dato : TDato;
Sig : TPuntero;
end record;

Type TPila is record

Cab : TPuntero;
Vacia : Boolean := True;
end record;

end;

ADB

with Text_IO;
with Unchecked_Deallocation;
use Text_IO;

package body Pila_Generica_Dinamica is

procedure Free is new Unchecked_Deallocation (TNodo,TPuntero);

function Vacia (Pila : in TPila) return Boolean is

begin
return Pila.Cab = null;
end;

5
Programación. Tema 4: Pilas y Colas (16/Mayo/2004)

procedure Push (Pila: in out TPila; Dato: in TDato) is

NuevoNodo : TPuntero := new TNodo;
begin
NuevoNodo.Dato := Dato;
NuevoNodo.Sig := Pila.Cab;
Pila.Cab := NuevoNodo;
Pila.Vacia := False;
end;

procedure Pop ( Pila : in out TPila; Dato : out TDato) is

P : TPuntero;
begin
if Pila.Vacia = True then
raise Vacia;
end if;
P := Pila.Cab;
Pila.Cab := Pila.Cab.Sig;
P.Sig := null;
Dato := P.Dato;
Free(P);
if Pila.Cab = null then
Pila.Vacia := True;
else
Pila.Vacia := False;
end if;
end;

procedure Reset (Pila : in out TPila) is

P : TPuntero;
begin
while Pila.Cab /= null loop
P := Pila.Cab;
Pila.Cab := Pila.Cab.Sig;
P.Sig := null;
Free (P);
end loop;
Pila.Vacia := True;
end;
end;