1. Capítulo 3. Colas
3 Colas
3.1 Descripción del TDA Cola.
3.2 Especificación del TDA Cola.
3.3 Ejemplos de uso.
3.4 Implementaciones del TDA Cola.
3.4.1 Implementación basada en el TDA Lista.
3.4.2 Implementación con vectores circulares.
3.4.3 Implementación con apuntadores.
3.4.4 Comparación de las implementaciones.
3.5 Modalidades de colas.
3.5.1 Dicolas.
3.5.2 Colas de Prioridad

2. 3.1 Descripción del TDA Cola
t Una cola es un caso particular de lista en el cual los elementos se
insertan en un extremo (el posterior o final) y se suprimen en el
otro (el anterior o frente).
t Las colas se conocen también como listas FIFO ( first-in first-out)
o listas ``primero en entrar, primero en salir''.
t Algunas de las operaciones vistas para listas pierden sentido
en el TDA Cola y se definen nuevas operaciones

3. 3.1 Descripción del TDA Cola
t Podemos definir las siguientes operaciones:
t CREA. Crea una cola vacía.
t VACIA. Devuelve un valor cierto si la cola está vacía, y falso en
caso contrario.
t PRIMERO. Devuelve el primer elemento de una cola.
t INSERTA. Añade un elemento por el extremo final de una cola.
t SUPRIME. Suprime el primer elemento de una cola.

4. 3.2 Especificación del TDA Cola
Especificación Informal
t Cola = TDA con operaciones crea, vacia, primero,
inserta, suprime.
t DESCRIPCIÓN:
t Los valores del TDA Cola son colas de elementos del tipo
Elemento. Las colas son mutables: inserta y suprime
añaden y eliminan elementos en la cola respectivamente.
t OPERACIONES:
t crea() devuelve (C:Cola)
t efecto: Devuelve la cola vacía C.

5. 3.2 Especificación del TDA Cola
t vacia(C:Cola) devuelve (booleano)
t efecto: Devuelve cierto si C es la cola vacía, y falso en
caso contrario.
t primero(C:Cola) devuelve (E:Elemento)
t requerimientos: La cola C es no vacía.
t efecto: Devuelve en E el primer elemento de la cola C.
t inserta(C:Cola; E:Elemento)
t modifica: C.
t efecto: Añade el elemento E por el extremo final de la cola C
t suprime(C:Cola)
t requerimientos: La cola C es no vacía.
t modifica: C.
t efecto: Suprime el primer elemento de la cola C.

6. 3.2 Especificación del TDA Cola
Especificación Formal
Tipo: Cola (Elemento)
t Sintaxis:
t crea → Cola
t vacia(Cola) → booleano
t primero(Cola) → Elemento
t inserta(Cola,Elemento) → Cola
t suprime(Cola) → Cola
t Semántica:
t vacia(crea) ⇒ cierto
t vacia(inserta(C,E)) ⇒ falso
t primero(crea) ⇒ error
t primero(inserta(C,E)) ⇒ si vacia(C) → E |primero(C)
t suprime(crea) ⇒ error
t suprime(inserta(C,E)) ⇒ si vacia(C)→crea|inserta(suprime(C),E)

7. 3.2 Especificación del TDA Cola
La interface Java del TDA Cola de acuerdo a esta
especificación puede definirse de la siguiente forma:
package colaInterface;
import colaException.*;
public interface Cola {
public boolean vacia();
public Object primero() throws ColaVaciaException;
public void inserta(Object elemento);
public void suprime() throws ColaVaciaException;
} // fin class Cola

8. 3.2 Especificación del TDA Cola
Las excepciones para Cola:
package colaException;
public class ColaException extends Exception {
public ColaException() { super(); };
public ColaException(String s) { super(s); };
}
package colaException;
public class ColaVaciaException extends ColaException {
public ColaVaciaException() { super(); };
public ColaVaciaException(String s) { super(s); };
}

9. 3.3 Ejemplos de uso
import colaInterface.*;
import colaException.*;
import java.io.*;
public class ColaUtil {
static public void imprimir(Cola cola) {
try {
Cola colaAux = duplicar(cola);
while (!colaAux.vacia()) {
Object e = colaAux.primero();
colaAux.suprime();
System.out.print(e+" ");
}
System.out.println();
} catch (ColaException e) {
System.err.println("Error en el uso de la Cola: "+e);
}
} // fin imprimir()

10. 3.3 Ejemplos de uso
static public Cola duplicar(Cola cola) {
try {
Cola cola2 = (Cola)cola.getClass().newInstance();
Cola colaAux = (Cola)cola.getClass().newInstance();
while (!cola.vacia()) {
Object e = cola.primero();
cola.suprime();
cola2.inserta(e);
colaAux.inserta(e);
}
while (!colaAux.vacia()) {
Object e = colaAux.primero();
colaAux.suprime();
cola.inserta(e);
}
return cola2;
} catch (ColaException e) {
System.err.println("Error en el uso de la Cola: "+e);
} catch (Exception e) { System.err.println(e); }
return null;
} // fin duplicar()

11. 3.3 Ejemplos de uso
static public Cola concatenar(Cola cola1, Cola cola2) {
try {
Cola cola3 = (Cola)cola1.getClass().newInstance();
Cola colaAux = duplicar(cola1);
while (!colaAux.vacia()) {
Object e = colaAux.primero();
colaAux.suprime(); cola3.inserta(e);
}
colaAux = duplicar(cola2);
while (!colaAux.vacia()) {
Object e = colaAux.primero();
colaAux.suprime(); cola3.inserta(e);
}
return cola3;
} catch (ColaException e) {
System.err.println("Error en el uso de la Cola: "+e);
} catch (Exception e) { System.err.println(e); }
return null;
} // fin concatenar
} // fin class ColaUtil

12. 3.4 Implementaciones del TDA Cola
t En esta sección mostraremos tres implementaciones
para el TDA Cola:
t Implementación basada en el TDA Lista
t Implementación con vectores circulares
t Implementación con apuntadores

13. 3.4.1 Implementación basada en el TDA Lista
package colaBasadaLista;
import colaException.*;
import listaException.*;
import listaSimpleEnlazada.*;
public class Cola implements colaInterface.Cola {
private Lista lista;
public Cola() {
lista = new Lista();
}
public boolean vacia() {
return lista.vacia();
}
public Object primero() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
try {
return lista.recupera(lista.primero());
} catch (ListaException e) {
System.err.println("Error interno de la Cola: "+e);
return null;
}
}

14. 3.4.1 Implementación basada en el TDA Lista
public void inserta(Object elemento) {
lista.inserta(lista.fin(),elemento);
}
public void suprime() throws ColaVaciaException{
if (vacia()) throw new ColaVaciaException();
try {
lista.suprime(lista.primero());
} catch (ListaException e) {
System.err.println("Error interno de la Cola: "+e);
}
}
} // fin class Cola

15. 3.4.1 Implementación basada en vectores circulares
...
a1 an
frente a2 an-1 post
...
public class Cola {
private static int max = 100;
private Object elementos[];
private int frente, post;
} // fin clase Cola

16. 3.4.2 Implementación basada en vectores circulares
package colaVectoresCirculares;
import colaException.*;
public class Cola implements colaInterface.Cola {
private static int max = 100;
private Object elementos[];
private int frente, post;
public Cola() {
elementos = new Object[max+1];
frente = 1;
post = 0;
}
public boolean vacia() {
return (frente == ((post+1)%(max+1)));
}

17. 3.4.2 Implementación basada en vectores circulares
public Object primero() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
return elementos[frente];
}
public void inserta(Object elemento) {
post = (post+1)%(max+1);
elementos[post]=elemento;
}
public void suprime() throws ColaVaciaException{
if (vacia()) throw new ColaVaciaException();
frente = (frente+1)%(max+1);
}
} // fin clase Cola

18. 3.4.3 Implementación con apuntadores
package colaSimpleEnlazada;
import colaException.*;
public class Cola implements colaInterface.Cola {
class Celda {
Object elemento;
Celda sig;
}
private Celda frente,post;
public Cola() {
frente = new Celda();
frente.sig = null;
post = frente;
}
public boolean vacia() {
return (frente==post);
}

19. 3.4.3 Implementación con apuntadores
public Object primero() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
return frente.sig.elemento;
}
public void inserta(Object elemento) {
post.sig = new Celda();
post = post.sig;
post.elemento = elemento;
post.sig = null;
}
public void suprime() throws ColaVaciaException{
if (vacia()) throw new ColaVaciaException();
frente = frente.sig;
}
} // fin clase Cola

20. 3.4.4 Comparación de las Implementaciones
q Los criterios descritos en el capítulo anterior para la
comparación de las implementaciones de listas son
también válidos para las implementaciones de colas.
q La elección de una implementación u otra dependerá de
los requerimientos de la aplicación en la que se use.
q Es posible obtener representaciones para colas que
permiten operaciones eficientes con tiempos de ejecución
constantes.

21. 3.5 Modalidades de colas
t En esta sección mostraremos dos
modalidades usuales de colas:
t Dicolas
t Colas de Prioridad

22. 3.5.1 Dicolas
Las Dicolas son casos particulares de listas y
generalizaciones de colas en donde las eliminaciones e
inserciones pueden realizarse en ambos extremos de la
lista.
El conjunto de operaciones de una dicola consiste en las
operaciones de una cola junto con las siguientes:
public Object ultimo() throws ColaVaciaException;
public void inserta_frente(Object elemento);
public void suprime_post() throws
ColaVaciaException;

23. 3.5.2 Colas de Prioridad
Una cola de prioridad es una cola a cuyos elementos se les
ha asignado una prioridad, de forma que el orden en que los
elementos son procesados sigue las siguientes reglas:
t El elemento con mayor prioridad es procesado primero.
t Dos elementos con la misma prioridad son procesados
según el orden en que fueron introducidos en la cola.

24. 3.5.2 Colas de Prioridad
Existen dos métodos básicos para la representación de colas de
prioridad mediante estructuras lineales:
t Tener la cola siempre ordenada de acuerdo a las prioridades de
sus elementos, y sacar cada vez el primer elemento de ésta, es
decir, el de mayor prioridad. En este caso, cuando se introduce
un elemento en la cola, debe insertarse en el lugar
correspondiente de acuerdo a su prioridad.
t Insertar los elementos siempre al final de la cola, y cuando se
va a sacar un elemento, buscar el que tiene mayor prioridad.
Nosotros usaremos el método (a), ya que la búsqueda de la posición
en la cual se inserta un elemento nuevo requiere menos
operaciones que la búsqueda del elemento que se saca para el
caso (b).
Ya que los elementos se insertarán en cualquier posición de la cola, la
representación con simple enlace es la más apropiada.

25. 3.5.2 Colas de Prioridad
La interface en Java del TDA Cola de Prioridad puede ser la
siguiente:
package colaPrioridadInterface;
import colaException.*;
public interface ColaPrioridad {
public boolean vacia();
public Object primero() throws ColaVaciaException;
public int primero_prioridad() throws ColaVaciaException;
public void inserta(Object elemento, int prioridad);
public void suprime() throws ColaVaciaException;
} // fin interface ColaPrioridad

26. 3.5.2 Colas de Prioridad
Una implementación en Java de la Cola de Prioridad mediante
simple enlace puede realizarse de la siguiente forma:
package colaPrioridadSimpleEnlazada;
import colaException.*;
public class ColaPrioridad implements colaPrioridadInterface.ColaPrioridad {
class Celda {
Object elemento;
int prioridad;
Celda sig;
}
private Celda cola;
public ColaPrioridad() {
cola = new Celda();
cola.sig = null;
}

27. 3.5.2 Colas de Prioridad
public boolean vacia() {
return (cola.sig==null);
}
public Object primero() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
return cola.sig.elemento;
}
public int primero_prioridad() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
return cola.sig.prioridad;
}
public int primero_prioridad() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
return cola.sig.prioridad;
}

28. 3.5.2 Colas de Prioridad
public void inserta(Object elemento, int prioridad) {
Celda p,q;
boolean encontrado = false;
p = cola;
while((p.sig!=null)&&(!encontrado)) {
if (p.sig.prioridad<prioridad)
encontrado = true;
else p = p.sig;
}
q = p.sig;
p.sig = new Celda();
p = p.sig;
p.elemento = elemento;
p.prioridad = prioridad;
p.sig = q;
}
public void suprime() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
cola = cola.sig;
}
} // fin clase ColaPrioridad