Captulo 3.

Colas
3 Colas
3.1 Descripcin del TDA Cola.
3.2 Especificacin del TDA Cola.
3.3 Ejemplos de uso.
3.4 Implementaciones del TDA Cola.
3.4.1 Implementacin basada en el TDA Lista.
3.4.2 Implementacin con vectores circulares.
3.4.3 Implementacin con apuntadores.
3.4.4 Comparacin de las implementaciones.
3.5 Modalidades de colas.
3.5.1 Dicolas.
3.5.2 Colas de Prioridad
3.1 Descripcin del TDA Cola
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).

Las colas se conocen tambin como listas FI FO ( first-in first-out)
o listas ``primero en entrar, primero en salir''.

Algunas de las operaciones vistas para listas pierden
sentido en el TDA Cola y se definen nuevas operaciones
3.1 Descripcin del TDA Cola
Podemos definir las siguientes operaciones:
CREA. Crea una cola vaca.
VACIA. Devuelve un valor cierto si la cola est vaca, y falso en
caso contrario.
PRIMERO. Devuelve el primer elemento de una cola.
INSERTA. Aade un elemento por el extremo final de una cola.
SUPRIME. Suprime el primer elemento de una cola.
3.2 Especificacin del TDA Cola
Especificacin Informal

Cola = TDA con operaciones crea, vacia, primero,
inserta, suprime.

DESCRIPCIN:
Los valores del TDA Cola son colas de elementos del tipo
Elemento. Las colas son mutables: inserta y suprime
aaden y eliminan elementos en la cola respectivamente.

OPERACIONES:
crea() devuelve (C:Cola)
efecto: Devuelve la cola vaca C.
3.2 Especificacin del TDA Cola
vacia(C:Cola) devuelve (booleano)
efecto: Devuelve cierto si C es la cola vaca, y falso en
caso contrario.

primero(C:Cola) devuelve (E:Elemento)
requerimientos: La cola C es no vaca.
efecto: Devuelve en E el primer elemento de la cola C.

inserta(C:Cola; E:Elemento)
modifica: C.
efecto: Aade el elemento E por el extremo final de la cola C

suprime(C:Cola)
requerimientos: La cola C es no vaca.
modifica: C.
efecto: Suprime el primer elemento de la cola C.
3.2 Especificacin del TDA Cola
Especificacin Formal
Tipo: Cola (Elemento)
Sintaxis:
crea Cola
vacia(Cola) booleano
primero(Cola) Elemento
inserta(Cola,Elemento) Cola
suprime(Cola) Cola
Semntica:
vacia(crea) cierto
vacia(inserta(C,E)) falso
primero(crea) error
primero(inserta(C,E)) si vacia(C) E |primero(C)
suprime(crea) error
suprime(inserta(C,E)) si vacia(C)crea|inserta(suprime(C),E)
3.2 Especificacin del TDA Cola
La interface Java del TDA Cola de acuerdo a esta
especificacin 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
3.2 Especificacin 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); };
}
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()
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()
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

3.4 Implementaciones del TDA Cola
En esta seccin mostraremos tres implementaciones
para el TDA Cola:
Implementacin basada en el TDA Lista
Implementacin con vectores circulares
Implementacin con apuntadores
3.4.1 Implementacin 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;
}
}
3.4.1 Implementacin 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
3.4.1 Implementacin basada en vectores circulares












public class Cola {
private static int max = 100;
private Object elementos[];
private int frente, post;
} // fin clase Cola
a
1
a
2
a
n
a
n-1
...

...

frente
post
3.4.2 Implementacin 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)));
}
3.4.2 Implementacin 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
3.4.3 Implementacin 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);
}
3.4.3 Implementacin 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
3.4.4 Comparacin de las Implementaciones
Los criterios descritos en el captulo anterior para la
comparacin de las implementaciones de listas son
tambin vlidos para las implementaciones de colas.
La eleccin de una implementacin u otra depender de
los requerimientos de la aplicacin en la que se use.
Es posible obtener representaciones para colas que
permiten operaciones eficientes con tiempos de ejecucin
constantes.

3.5 Modalidades de colas
En esta seccin mostraremos dos
modalidades usuales de colas:
Dicolas
Colas de Prioridad
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;
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:

El elemento con mayor prioridad es procesado primero.
Dos elementos con la misma prioridad son procesados
segn el orden en que fueron introducidos en la cola.
3.5.2 Colas de Prioridad
Existen dos mtodos bsicos para la representacin de colas de
prioridad mediante estructuras lineales:
a) 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.
b) 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 mtodo (a), ya que la bsqueda de la
posicin en la cual se inserta un elemento nuevo requiere
menos operaciones que la bsqueda del elemento que se saca
para el caso (b).
Ya que los elementos se insertarn en cualquier posicin de la cola, la
representacin con simple enlace es la ms apropiada.
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
3.5.2 Colas de Prioridad
Una implementacin 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;
}
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;
}
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