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
 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.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.
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.
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.
 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)
 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
 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); };
}
 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 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
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;
        }
    }
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

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
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)));
    }
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

 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);
    }
 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

 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.
 3.5 Modalidades de colas

 En esta sección 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
según el orden en que fueron introducidos en la cola.
 3.5.2 Colas de Prioridad
Existen  dos  métodos básicos para la representación 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 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.
 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 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;
    }
 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