Download
1 / 27
E N D
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 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 también como listas FIFO ( 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. 3.1 Descripción del TDA Cola Podemos definir las siguientes operaciones:
CREA. Crea una cola vacía.
VACIA. Devuelve un valor cierto si la cola está vacía, y falso en caso contrario.
PRIMERO. Devuelve el primer elemento de una cola.
INSERTA. Añade un elemento por el extremo final de una cola.
SUPRIME. Suprime el primer elemento de una cola.
4. 3.2 Especificación del TDA Cola Especificación Informal
Cola = TDA con operaciones crea, vacia, primero, inserta, suprime.
DESCRIPCIÓN:
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.
OPERACIONES:
crea() devuelve (C:Cola)
efecto: Devuelve la cola vacía C.
5. 3.2 Especificación del TDA Cola vacia(C:Cola) devuelve (booleano)
efecto: Devuelve cierto si C es la cola vacía, y falso en caso contrario.
primero(C:Cola) devuelve (E:Elemento)
requerimientos: La cola C es no vacía.
efecto: Devuelve en E el primer elemento de la cola C.
inserta(C:Cola; E:Elemento)
modifica: C.
efecto: Añade el elemento E por el extremo final de la cola C
suprime(C:Cola)
requerimientos: La cola C es no vacía.
modifica: C.
efecto: Suprime el primer elemento de la cola C.
6. 3.2 Especificación del TDA Cola Especificación Formal
Tipo: Cola (Elemento)
Sintaxis:
crea ? Cola
vacia(Cola) ? booleano
primero(Cola) ? Elemento
inserta(Cola,Elemento) ? Cola
suprime(Cola) ? Cola
Semántica:
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)
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 En esta sección mostraremos tres implementaciones para el TDA Cola:
Implementación basada en el TDA Lista
Implementación con vectores circulares
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
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 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.
La elección de una implementación u otra dependerá de los requerimientos de la aplicación en la que se use.
Es posible obtener representaciones para colas que permiten operaciones eficientes con tiempos de ejecución constantes.
21. 3.5 Modalidades de colas En esta sección mostraremos dos modalidades usuales de colas:
Dicolas
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:
El elemento con mayor prioridad es procesado primero.
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:
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.
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
