Este documento describe las colas, que son listas lineales donde las operaciones de inserción y eliminación se realizan en extremos opuestos. Las colas siguen el principio FIFO, donde el primer elemento en entrar es el primero en salir. El documento también describe diferentes tipos de colas como colas circulares y bicolas, así como su implementación en Java.

1. Colas

2. COLAS
Definicion. Es una lista lineal de elementos en la que
las operaciones de insertar y eliminar se realizan en
diferentes extremos de la cola.
Trabajan con filosofía FIFO ( First In - First out), el
primer elemento en entrar es el primer elemento en
salir.
Ejemplos:
•Cola de automóviles esperando servicio en una gasolinera
•Cola de clientes en una ventanilla del banco para pagar un
servicio
•Cola de programas en espera de ser ejecutados por una
computadora.

3. Es una lista en la que las supresiones se realizan
solamente al principio de la lista y las inserciones
al final de la misma.
0 1 2 3 4 5 6 7 . . . N
P U
(PRIMERO) (ÚLTIMO)
PEPS = Primero Entrar - Primero Salir

4. Las colas abundan en la vida cotidiana:

5. TIPOS DE COLAS:
• Cola simple: Estructura lineal donde los elementos
salen en el mismo orden en que llegan.
• Cola circular: Representación lógica de una cola simple
en un arreglo.
• Cola Doble (Bicola): Estructura lineal en la que los
elementos se pueden añadir o quitar por cualquier
extremo de la cola (cola bidireccional).
• Cola de Prioridades: Estructura lineal en la cual los
elementos se insertan en cualquier posición de la cola y
se remueven solamente por el frente.

6. Operaciones: Estado de la cola:
Inicio: Cola Vacía
1.- Insertar A A
2.- Insertar B A B
3.- Insertar C A B C
4.- Remover Elemento B C
5.- Insertar D
B C D
6.- Remover Elemento
C D

7. Las colas pueden ser representadas en
arreglos de una dimensión (vector)
manteniendo dos variables que indiquen el
FRENTE y FINAL de los elementos de la cola.
0 1 2 3 4 5
A F S D Z
Frente Final

8. • Cuando la cola esta vacía las variables frente y
final son nulos y no es posible remover elementos.
• Cuando la cola esta llena ( frente = 0 y final = n-1)
no es posible insertar elementos nuevos a la cola.
• Cuando se remueven elementos el frente puede
incrementarse para apuntar al siguiente elemento
de la cola.
• Cuando no hay espacios libres al final del arreglo
los elementos pueden ser desplazados para
desocupar posiciones del arreglo o se puede
manejar una estructura circular.

9. Ejemplo: Suponer que usamos un arreglo de 5
posiciones.
Frente A B C
Final Frente Final
Al remover un elemento: B C
Frente Final
Insertar elemento D: B C D

10. Frente Final
Insertar elemento E:
B C D
E
Final
Insertar elemento F:
Frente B C D E
F
Insertar elemento G:
Error: Cola llena!!!!

11. Representación de colas:
• Usando memoria estática: arreglos con tamaño
fijo.
Final
Frente B C D E
F
0 1 2 3 4
• Usando memoria dinámica: Listas ligadas.
Final
B C D E F
Frente

12. Definición de un tipo abstracto: Cola
Insertar.- Almacena en la cola el elemento que se recibe
como paramétro.
Eliminar.- Saca de la cola el elemento que se encuentra al
frente.
Vacía.- Regresa un valor booleano indicando si la cola
tiene o no elementos (true – si la cola esta vacia, false –
si la cola tiene al menos un elemento).
Llena.- Regresa un valor booleano indicando si la cola
tiene espacio disponible para insertar nuevos elementos
( true – si esta llena y false si existen espacios
disponibles).

13. Interface de un TDA llamado Cola:
interface ICola{
public boolean llena();
public boolean vacia();
public void insertar (Object elem);
public Object eliminar();
}

14. Cola simple
Es una lista lineal de elementos en la que las
operaciones de insertar y eliminar se realizan en
diferentes extremos de la cola. Para lo cual hace uso de
dos indices frente y final.
Este tipo de cola presenta desaprovechamiento de
memoria al momento que se retiran elementos de la cola
ya que esa localidad queda libre; para evitar este
desaprovechamiento de memoria tenemos dos
soluciones:
1.- Mover todos los elementos de la cola una posición
cada vez que se quiere retirar un elemento de la cola
2.- Cuando final =max-1 y frente >0 mover todos los
elementos.

15. Implementacion de la clase Cola
Sencilla
 Ver ejemplo Cola.java
Insertar_Cola(1); Final
Insertar_Cola(2);
Insertar_Cola(3); Frente 1 2 3 4
5
Insertar_Cola(4);
Insertar_Cola(5);
retirar_Cola(); Frente Final
retirar_Cola();
Insertar_Cola(7); 3 4
Error no se puede 5
final esta en max-1

16. Cola Sencilla con la primera
solucion Final
 Ver ejemplo Frente 1 2 3 4
Cola_Sencilla1
Insertar_Cola(1); Final
Insertar_Cola(2);
Insertar_Cola(3); Frente 2 3 4
Insertar_Cola(4);
retirar_Cola(); Final
retirar_Cola();
Frente 3 4

17. EJERCICIO: Cola Sencilla con la
segunda solución
 Realizar el cambio para la solución 2
 ejemplo Cola_Sencilla

19. Colas Circulares
Es una variación de las colas sencillas para
hacer un uso más eficiente de la memoria
disponible, se trata a la estructura de cola
de forma circular. Es decir el elemento
anterior al primero es el último

20. COLA CIRCULAR
Funciona igual que la cola simple, pero optimiza
el uso de memoria (al reutilizar localidades
disponibles).
1) Inicialmente vacía COLA
1 2 3 4 5
P=0
U=0
COLAS

21. COLA
2) Se inserta A,B,C,D,E 1 2 3 4 5
P=1
A B C D E
U=5
P U
3) Eliminar A 1 2 3 4 5
P=2
A B C D E
U=5
P U
4) Insertar F 1 2 3 4 5
P=2 P=2 F B C D E
U=5 U=1
P U
COLAS

22. 2 P
1 B 3
INSERTAR F
C
E D
5
U 4
2 P
1 B
U
F 3
SI U+1 = P
C
COLA CIRCULAR
E
LLENA D
5
4
COLAS

23. OTRO EJEMPLO: N= 5
COLA
1) Se inserta A,B,C,D,E 1 2 3 4 5
P=1
A B C D E
U=5
P U
2) Se inserta F
NO SE PUEDE INSERTAR “F” PORQUE LA
COLA CIRCULAR LLENA, U=N y P=1.
SRR COLAS

24. Frente Final
Cola
B C D
Cola Circular inicial
Frente Final
Es una Remover
representación C D
lógica de la cola en
un arreglo. Frente Final
El frente y final son Insertar E
movibles. C D
Cuando el frente o E
Final Frente
final llegan al
Insertar F
extremo se
F C D
regresan a la
E
primera posición
del arreglo.

25. Ejemplo de cola circular
class ColaCirc max=3
InsColaCirc(A);
InsColaCirc(B);
InsColaCirc(C);
RetColaCirc();
RetColaCirc();
InsColaCirc(D);
InsColaCirc(F);
InsColaCirc(E); DESBORDAMIENTO

26. Ejercicio para clase
 Modificar el programa anterior ColaCirc modificando y
agregando los métodos:
ColaCirc_llena()
ColaCirc_vacia()
InsColaCirc(Object dato)
RetColaCirc()
 Hacer un programa, que contenga un menú para llamar
los métodos de inserción y retiro de los elementos de la
cola circular.

27. BICOLA
 Es una variación del tipo de datos cola.
Una bicola:
es un conjunto de elementos en el cual se
pueden añadir o quitar elementos de cualquier
extremo de la misma.
Los dos extremos de una bicola los llamaremos
izquierdo y derecho

28. Operaciones Básicas de una bicola
CrearB.- inicializa una bicola sin elementos
EsVacía.- Regresa un valor booleano indicando si la bicola tiene o no
elementos .
InsertarIZQ.- Añade un elemento por el extremo izquierdo.
InsertarDER.- Añade un elemento por el extremo derecho.
EliminarIZQ.- Devuelve el elemento Izquierdo y lo retira de la bicola.
EliminarDER.- Devuelve el elemento Derecho y lo retira de la bicola.

29. Representacion estática
 Se mantienen los elementos de la bicola
en un arreglo circular.
 Se utilizan dos variables indice Izquierdo y
Derecho.

30. Restricciones en las bicolas
 Restricciones de entrada: Es aquella que solo
permite inserciones por uno de los extremos,
pero permite la eliminación por los dos
extremos.
 Restricciones de salida: Es aquella que
permite inserciones por los dos extremos, pero
solo permite retirar elementos por un extremo.

31. Estructura tipo bicola
Frente: 2 0 1 2 3 4 5 6 7 8 9
luz agua rió
Final: 4
Al añadir el elemento sql por el frente:
Frente: 1
0 1 2 3 4 5 6 7 8 9
sql luz agua rió
Final: 4
Puede eleiminar por el final:
Frente: 1 0 1 2 3 4 5 6 7 8 9
sql luz agua
Final: 3

32.  Implementar la clase bicola
Problema:
 El estacionamiento de las avionetas de un aeropuerto es en línea,
con una capacidad de 12 avionetas.
 Las avionetas llegan por el extremo izquierdo y salen por el extremo
derecho.
 Cuando llega un piloto a recoger su avioneta, si esta no esta
justamente en el extremo de salida (derecho), todas las avionetas a
su derecha han de ser retiradas, sacar la suya y las avionetas
retiradas son colocadas de nuevo en el mismo orden en que
estaban.
 La salida de una avioneta supone que las demás se mueven hacia
delante, de tal forma que los espacios libres del estacionamiento
están en la parte izquierda.

33.  El programa para emular este estacionamiento tiene como entrada
un carácter que indica una acción sobre la avioneta, y la matricula
de la avioneta.
 La acción puede ser llegada (E) o salida (S) de avioneta.
 En la llegada puede ocurrir que el estacionamiento este lleno, si es
así la avioneta espera hasta que se quede una placa libre, o hasta
que se dé orden de retirada (salida).

34. Análisis del programa
 El estacionamiento va a estar representado por una bicola de salida
restringida ¿Por qué? La salida siempre se hace por el mismo
extremo, sin embargo la entrada se puede hacer por los dos
extremos, y así contemplar la llegada de una avioneta nueva ,y que
tenga que entrar una avioneta que ha sido movida para que salga
una intermedia.
 La línea de espera para entrada de una avioneta (estacionamiento
lleno) se representa por una bicola a la que se añaden avionetas
por un extremo, salen para entrar en el estacionamiento por el otro
extremo.
 Las avionetas que se mueven para poder retirar del
estacionamiento una intermedia se almacenan en una lista lifo
(pila); asi la última en entrar será la primera en añadirse en el
extremo salida del estacionamiento y seguirá en el mismo orden.
 La restricción de salida se refleja en que no es valida la operación
retirar por el extremo de salida

35. Colas en Java
 Java contiene la definición de interfaces y
clases para el manejo de colas.
 Las colas son una colección de elementos
diseñadas para almacenar elementos que
esperan ser procesados.
 Java contiene una interface
parametrizada Queue<E> y varias clases
que que la implementan, entre ellas
PriorityQueue<E>

36. Colas en Java
public interface Queue<E> extends Collection<E>
{
E element();
boolean offer(E o);
E peek();
E poll();
E remove();
}

37. Method Summary
E element()
Retrieves, but does not remove, the head of this queue, it throws an exception if this
queue is empty..
bool offer(E o)
ean Inserts the specified element into this queue, if possible.
E
peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is
empty.
E
poll()
Retrieves and removes the head of this queue, or null if this queue is empty.
E remove()
Retrieves and removes the head of this queue.

38. Cola de Prioridad en Java
java.util
Class PriorityQueue<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
java.util.PriorityQueue<E>
Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:
Serializable, Iterable<E>, Collection<E>, Queue<E>

39. Constructor Summary
PriorityQueue ()
Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to
their natural ordering (using Comparable).
PriorityQueue (Collection<? extends E> c)
Creates a PriorityQueue containing the elements in the specified collection.
PriorityQueue (int initialCapacity)
Creates a PriorityQueue with the specified initial capacity that orders its elements according to
their natural ordering (using Comparable).
PriorityQueue (int initialCapacity, Comparator<? super E> comparator)
Creates a PriorityQueue with the specified initial capacity that orders its elements according to the
specified comparator.
PriorityQueue (PriorityQueue<? extends E> c)
Creates a PriorityQueue containing the elements in the specified collection.
PriorityQueue (SortedSet<? extends E> c)
Creates a PriorityQueue containing the elements in the specified collection.

40. Method Summary
boolean add(E o)
Adds the specified element to this queue.
void clear()
Removes all elements from the priority queue.
Comparato
r<? super comparator()
E> Returns the comparator used to order this collection, or null if this collection is sorted
according to its elements natural ordering (using Comparable).
Iterator<E> iterator()
Returns an iterator over the elements in this queue.
boolean offer(E o)
Inserts the specified element into this priority queue.
E peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.
E poll()
Retrieves and removes the head of this queue, or null if this queue is empty.
boolean remove(Object o)
Removes a single instance of the specified element from this queue, if it is present.
int size()
Returns the number of elements in this collection.