You are on page 1of 12

©M.

Aldea
EstructurasdeDatos Oct-13 1
Estructuras de Datos
Tema 1. Introducción
Tema 2. Análisis de Algoritmos
Tema 3. Listas
Tema 4. Pilas y Colas
Tema 5. Árboles
Tema 6. TDAs ordenados
Tema 7. Mapas
Tema 8. Conjuntos, Bolsas y Listas sin repetición
Tema 9. Grafos
Tema4. Pilas y Colas

©M. Aldea
EstructurasdeDatos Oct-13 2
Tema 4. Pilas y Colas
4.1. TDA Pila
4.2. Implementación de Pilas basada en array
4.3. Implementación de Pilas basada en celdas enlazadas
4.4. TDA Cola
4.5. Implementación de Colas basada en array circular
4.6. Implementación de Colas basada en celdas enlazadas
4.7. Comparación de las implementaciones
4.8. Pilas y Colas en “ Java Collections Framework”
4.9. Bibliografía
Tema4. Pilas y Colas

©M. Aldea
EstructurasdeDatos Oct-13 3
Objetivos
• Conocer los TDAs Pila y Cola
• Conocer las técnicas básicas de implementación de Pilas y
Colas: basadas en array y basadas en estructuras enlazadas
• Conocer las ventajas e inconvenientes de las distintas técnicas
de implementación de acuerdo a su complejidad espacial y
temporal
• Conocer el soporte proporcionado para Pilas y Colas en las
“ Java Collections”
• Saber elegir el TDA Pila o Cola y su implementación que mejor
satisfaga los requisitos de una aplicación
Tema4. Pilas y Colas
4.1 TDA Pila
©M. Aldea
EstructurasdeDatos Oct-13 4
4.1 TDA Pila
Colección de elementos potencialmente repetidos donde la
posición de cada elemento es relevante y las inserciones y
eliminaciones sólo se pueden realizar en una posición
denominada “ cima”
• Es decir, los elementos se añaden y extraen en orden LIFO
(last-in-first-out, el último en entrar es el primero en salir)
A
B
C
D
A
B
C
D
A
B
C
D
A
B
C
D
E E
F
E
cima
desapila() apila(F)
cima
cima
cima
apila(E)
Tema4. Pilas y Colas
4.1 TDA Pila
©M. Aldea
EstructurasdeDatos Oct-13 5
Operaciones de las pilas
// añade el elemento en la cima de la pila
apila(e: Elemento)
// elimina y retorna el elemento que ocupaba la
// la cima. La cima pasa al siguiente elemento
desapila(): Elemento
// retorna (pero no elimina) el elemento que
// ocupa la cima. La cima no cambia.
cima(): Elemento
// vacía la pila (pasa a tener tamaño 0)
haceVacía()
// retorna el tamaño de la pila (num. elementos)
tamaño(): Entero
// indica si la pila está vacía
estáVacía(): Booleano
Tema4. Pilas y Colas
4.1 TDA Pila
©M. Aldea
EstructurasdeDatos Oct-13 6
Implementaciones de pilas
Pila
<<interface>>
E
+apila(e: E)
+desapila(): E
+cima(): E
+haceVacía(): void
+tamaño(): Entero
+estáVacía(): Bool
PilaArray
E
PilaSimpleEnlace
E
Tema4. Pilas y Colas
4.1 TDA Pila
©M. Aldea
EstructurasdeDatos Oct-13 7
Uso de pilas
*
-platos PlatosParaFregar
+dejaPlato(p: Plato)
Plato
{ordered, nonunique}
Pila de platos para fregar
+cogePlato():Plato
<<PilaArray>>
*
-operaciones
OperacionesDeEdición
+registraOp(Op: OperaciónDeEdición)
OperaciónDeEdición
{ordered, nonunique}
Pila de operaciones de edición para implementar el “deshacer” de un editor de texto
+últimaOp(): OperaciónDeEdición
<<PilaSimpleEnlace>>
Tema4. Pilas y Colas
4.2 Implementación dePilas basadaen array
©M. Aldea
EstructurasdeDatos Oct-13 8
4.2 Implementación de Pilas basada en array
Array de elementos y cursor que indica la cima de la pila
• cuando la pila está vacía cima=-1
elementos : Elemento[N]
cima : Entero
Elemento más viejo
cima=c
Segundo elemento más viejo
Segundo elemento más nuevo
Elemento más nuevo
...
0
1
...
N-1
parte libre
parte ocupada
c
c-1
c+1
elementos
Tema4. Pilas y Colas
4.2 Implementación dePilas basadaen array
©M. Aldea
EstructurasdeDatos Oct-13 9
Implementación dePilas basadaen array (cont.)
procedimiento apila(e: Elemento)
si tamaño() = N entonces
error // no caben más elementos
fsi
cima := cima + 1
elementos[cima] := e
fprocedimiento
procedimiento desapila(): Elemento
si estáVacía() entonces
error // no hay elementos
fsi
cima := cima - 1
retorna elementos[cima+1]
fprocedimiento
Tema4. Pilas y Colas
4.2 Implementación dePilas basadaen array
©M. Aldea
EstructurasdeDatos Oct-13 10
Implementación dePilas basadaen array (cont.)
procedimiento haceVacía()
cima := -1
fprocedimiento
procedimiento tamaño(): Entero
retorna cima + 1
fprocedimiento
procedimiento estáVacía(): Booleano
retorna cima = -1
fprocedimiento
procedimiento cima(): Elemento
si estáVacía() entonces
error
fsi
retorna elementos[cima]
fprocedimiento
Tema4. Pilas y Colas
4.3 Implementación dePilas basadaen celdas enlazadas
©M. Aldea
EstructurasdeDatos Oct-13 11
4.3 Implementación de Pilas basada en celdas
enlazadas
Implementación directa y eficiente (O(1)) utilizando celdas
simplemente enlazadas
• inserciones y extracciones por la cabeza de la lista de celdas
c b a
cima
apila(d)
c b a
cima
d
desapila()  retorna d
c b a
cima
Tema4. Pilas y Colas
4.4 TDA Cola
©M. Aldea
EstructurasdeDatos Oct-13 12
4.4 TDA Cola
Colección de elementos potencialmente repetidos donde la
posición de cada elemento es relevante, las inserciones sólo se
pueden realizar por el “ final” y las eliminaciones por el “ frente”
• Es decir, los elementos se añaden y extraen en orden FIFO
(first-in-first-out, el primero en entrar es el primero en salir)
a b d c
e
frente final
encola(e)
desencola()  retorna a
a b d c
frente final
b c e d
frente final
Tema4. Pilas y Colas
4.4 TDA Cola
©M. Aldea
EstructurasdeDatos Oct-13 13
Operaciones de las colas
// añade el elemento al final de la cola
encola(e: Elemento)
// elimina y retorna el elemento que ocupaba el
// frente. El siguiente elemento pasa al frente
desencola(): Elemento
// retorna (pero no elimina) el elemento que
// ocupa el frente. El frente no cambia.
frente(): Elemento
// vacía la cola (pasa a tener tamaño 0)
haceVacía()
// retorna el tamaño de la cola (num. elementos)
tamaño(): Entero
// indica si la cola está vacía
estáVacía(): Booleano
Tema4. Pilas y Colas
4.4 TDA Cola
©M. Aldea
EstructurasdeDatos Oct-13 14
Implementaciones de colas
Cola
<<interface>>
E
+encola(e: E)
+desencola(): E
+frente(): E
+haceVacía(): void
+tamaño(): Entero
+estáVacía(): Bool
ColaArray
E
ColaSimpleEnlace
E
Tema4. Pilas y Colas
4.4 TDA Cola
©M. Aldea
EstructurasdeDatos Oct-13 15
Uso de colas
*
-clientes
Cliente
{ordered}
Cola de la caja de un supermercado
<<ColaArray>>
*
-trabajos
TrabajoImpresión
{ordered, nonunique}
Cola de trabajos pendientes en una impresora
<<ColaSimpleEnlace>>
ClientesCaja
TrabajosPendientes
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 16
4.5 Implementación de Colas basada en array
circular
Array de elementos y dos cursores que indican el frente y el final
• “ array circular” : cuando un cursor sobrepasa la última posición
del array, vuelve a la primera
elementos : Elemento[N]
frente, final : Entero
Ejemplo. Dos configuraciones de cola válidas:
0 1 2 3 4 5
a
6
b
7
c
8
d
9
e
10 11 12 13 14 15
frente=6 final=10
k
0
l
1
m
2
n
3 4 5 6 7 8 9 10 11 12 13
i
14
j
15
frente=14 final=3
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 17
Implementación deColas basadaen array circular (cont.)
b
0 1 2 3 4 5
a
6
frente
final
b
0
c
1 2 3 4 5
a
6
final
b
0
c
1 2 3 4 5 6
final
frente
0 1 2 3 4 5 6
final
frente
encola(c)
desencola()a
frente
0
c
1 2 3 4 5 6
final
frente
desencola()b
desencola()c
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 18
Detección de cola vacía/llena
Hay dos opciones:
• Llevando un contador con el número de elementos
-Necesidad de una variable extra (el contador)
+Se puede llenar el array totalmente
• Utilizando la posición relativa de los cursores
+No hace falta ninguna variable extra
-Siempre debe quedar, al menos, una posición libre en el array
Son soluciones equivalentes
• no hay un acuerdo general sobre cual es mejor
• unas implementaciones/libros eligen una y otros otra
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 19
Detección de cola vacía/llena con los cursores
Vacía cuando frente está en la posición siguiente a final
(final + 1) mod N = frente
Problema: en una cola totalmente llena también se cumple que
frente está en la posición siguiente a final
• Solución: no se permite llenar la cola del todo
Llena cuando frente está dos posiciones por delante de final
(final + 2) mod N = frente
Tamaño de la cola: (N - frente + final + 1) mod N
0 1 2 3 4 5 6
final
frente
e
0
f
1
g
2
a
3
b
4
c
5
d
6
frente
final
e
0
f
1 2
a
3
b
4
c
5
d
6
frente
final
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 20
Implementación con contador de elementos
procedimiento haceVacía()
tamaño := 0
frente := 0
final := N - 1
fprocedimiento
procedimiento tamaño(): Entero
retorna tamaño
fprocedimiento
procedimiento estáVacía(): Booleano
retorna tamaño = 0
fprocedimiento
0 1 2 3 4 5 6
final
frente
tamaño=0
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 21
Implementación con contador deelementos (cont.)
procedimiento frente(): Elemento
si estáVacía() entonces
error
fsi
retorna elementos[frente]
fprocedimiento
procedimiento desencola(): Elemento
si estáVacía() entonces
error
fsi
tamaño := tamaño - 1
Elemento temp := elementos[frente]
frente := (frente + 1) mod N
retorna temp
fprocedimiento
Tema4. Pilas y Colas
4.5 Implementación deColas basadaen array circular
©M. Aldea
EstructurasdeDatos Oct-13 22
Implementación con contador deelementos (cont.)
procedimiento encola(e: Elemento)
si tamaño() = N entonces
error
fsi
tamaño := tamaño + 1
final := (final + 1) mod N
elementos[final] := e
fprocedimiento
mod: operador módulo (en Java es el operador “ %” )
• resto de la división entera
7 mod 4 = 3
18 mod 9 = 0
0 mod 4 = 0
Tema4. Pilas y Colas
4.6 Implementación deColas basadaen celdas enlazadas
©M. Aldea
EstructurasdeDatos Oct-13 23
4.6 Implementación de Colas basada en celdas
enlazadas
Implementación directa y eficiente utilizando celdas simplemente
enlazadas
• inserciones por el final y extracciones por el principio de la lista
a b c
frente
encola(d)
b c d
frente
a
desencola()  a
b c d
frente
final
final
final
Tema4. Pilas y Colas
4.6 Implementación deColas basadaen celdas enlazadas
©M. Aldea
EstructurasdeDatos Oct-13 24
Implementación deColas basadaen celdas enlazadas (cont.)
Implementación con celda de cabecera
tipo Celda
contenido : puntero a Elemento
siguiente : puntero a Celda
ftipo
frente : puntero a Celda
final : puntero a Celda
numEle : Entero
procedimiento Constructor
numEle := 0
frente := nueva Celda
frente.siguiente := null
final := frente
fprocedimiento
null
frente
final
Tema4. Pilas y Colas
4.6 Implementación deColas basadaen celdas enlazadas
©M. Aldea
EstructurasdeDatos Oct-13 25
Implementación deColas basadaen celdas enlazadas (cont.)
procedimiento encola(e : Elemento)
nuevaCelda : puntero a Celda := nueva Celda
nuevaCelda.contenido := e
numEle++
final.siguiente := nuevaCelda
final := nuevaCelda
fprocedimiento
procedimiento desencola(): Elemento
si estáVacía() entonces
error
fsi
numEle--
frente := frente.siguiente
retorna frente.contenido
fprocedimiento
a
frente
final
encola(z)
a
frente
z
final
a
frente
b
final
desencola()
frente
b
final
a
Tema4. Pilas y Colas
4.6 Implementación deColas basadaen celdas enlazadas
©M. Aldea
EstructurasdeDatos Oct-13 26
Implementación deColas basadaen celdas enlazadas (cont.)
procedimiento frente(): Elemento
si estáVacía() entonces
error
fsi
retorna frente.siguiente.contenido
fprocedimiento
procedimiento estáVacía(): Boolean
retorna numEle = 0
fprocedimiento
procedimiento haceVacía()
numEle := 0
frente := final
fprocedimiento
a
frente
b
final
haceVacía()
a
frente
b
final
Tema4. Pilas y Colas
4.7 Comparación delas implementaciones
©M. Aldea
EstructurasdeDatos Oct-13 27
4.7 Comparación de las implementaciones
Eficiencia temporal de las operaciones:
Es algo más rápida la implementación basada en array
Operación
pila/cola
Array y Lista enlazada
apila/encola O(1)
desapila/desencola O(1)
cima/frente O(1)
tamaño O(1)
haceVacía O(1)
estáVacía O(1)
Tema4. Pilas y Colas
4.7 Comparación delas implementaciones
©M. Aldea
EstructurasdeDatos Oct-13 28
Comparación delas implementaciones (cont.)
Características generales:
En general la implementación con array es más sencilla y eficiente
• debería usarse siempre que se tenga bien acotada la longitud
máxima que puede alcanzar la pila/cola
Característica Array Lista Enlazada
Requisitos de memoria
O(N), donde N es el tamaño del
array de elementos
O(n), donde n es el número
de elementos en la pila
Fácil crecimiento
No, requiere
redimensionado y copia
Sí, puesto que
no está acotada
Aprovechamiento de la
memoria
Desperdicia
memoria
Usa la memoria
justa
Tema4. Pilas y Colas
4.8 Pilas y Colas en “J avaCollections Framework”
©M. Aldea
EstructurasdeDatos Oct-13 29
4.8 Pilas y Colas en “Java Collections
Framework”
Cola
Pila
JCF NO incluye la
interfaz Stack (Pila)
<<interface>>
Collection
<<interface>>
Queue
<<interface>>
Iterable E
E
E
LinkedList
E
Tema4. Pilas y Colas
4.8 Pilas y Colas en “J avaCollections Framework”
©M. Aldea
EstructurasdeDatos Oct-13 30
Pilas en JCF
JFC no incluye ninguna interfaz específica para las pilas
Utilizaremos LinkedList
public class PlatosParaFregar {
private LinkedList<Plato> platos =
new LinkedList<Plato>();
...
*
-platos PlatosParaFregar
+dejaPlato(p: Plato)
Plato
{ordered, nonunique}
+cogePlato():Plato
<<LinkedList>>
Tema4. Pilas y Colas
4.8 Pilas y Colas en “J avaCollections Framework”
©M. Aldea
EstructurasdeDatos Oct-13 31
Pilas en J CF (cont.)
De la clase LinkedList usaremos los métodos:
void addFirst(E e); // apila
E removeFirst(); // desapila
// si cola vacía: lanza excepción
E getFirst(); // cima
// si cola vacía: lanza excepción
void clear(); // haceVacía
int size(); // tamaño
boolean isEmpty(); // estáVacía
Tema4. Pilas y Colas
4.8 Pilas y Colas en “J avaCollections Framework”
©M. Aldea
EstructurasdeDatos Oct-13 32
Colas en JCF
Interfaz Queue, utilizando su implementación LinkedList
public class TrabajosPendientes {
private Queue<TrabajoImpresión> trabajos =
new LinkedList<TabajoImpresión>();
...
*
-trabajos
TrabajoImpresión
{ordered, nonunique}
<<LinkedList>>
TrabajosPendientes
Tema4. Pilas y Colas
4.8 Pilas y Colas en “J avaCollections Framework”
©M. Aldea
EstructurasdeDatos Oct-13 33
Colas en J CF (cont.)
public interface Queue<E> extends Collection<E> {
// encola
boolean offer(E e);// si cola llena: retorna false
boolean add(E e);// si cola llena: lanza excepción
// frente
E peek(); // si cola vacía: retorna null
E element(); // si cola vacía: lanza excepción
// desencola
E poll(); // si cola vacía: retorna null
E remove(); // si cola vacía: lanza excepción
}
Además, de Collection hereda los métodos:
void clear(); // haceVacía
int size(); // tamaño
boolean isEmpty(); // estáVacía
Tema4. Pilas y Colas
4.9 Bibliografía
©M. Aldea
EstructurasdeDatos Oct-13 34
4.9 Bibliografía
[1] Michael T. Goodrich, Roberto Tamassia, Data structures and
algorithms in Java. John Wiley & Sons, 2006.
[2] Aho A.V., Hopcroft J.E., Ullman J.D., Estructuras de datos y
algoritmos. Addison-Wesley, 1988.
[3] Weiss, Mark Allen, Data Structures and Algorithm Analysis in
Java. Pearson Education, 2007.
[4] Weiss, Mark Allen, Estructuras de datos y algoritmos.
Addison-Wesley Iberoamericana, 1995.
[5] Sahni, Sartaj, Data structures, algorithms, and applications in
Java. McGraw Hill, 2000
[6] The Java Tutorials: Collections
http://docs.oracle.com/javase/tutorial/collections/index.html