Tipos de colas....

Cola Circular(Anillos).

Una cola circular o anillo es una estructura de datos en la que los elementos están de forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden cosultarse, añadirse y eliminarse únicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor, respectivamente, de la cabeza actual.

Codigo En Maude(anillos)

 

fmod ANILLO {X :: TRIV} is
        sorts AnilloNV{X} Anillo{X} .
        subsort AnilloNV{X} < Anillo{X} .

        op crear : -> Anillo{X} [ctor] .
        op insertar : X$Elt Anillo{X} -> AnilloNV {X} [ctor] .

        op eliminar : Anillo{X} -> Anillo{X} .
        ops rotarDch rotarIzq : Anillo{X} -> Anillo{X} .
        op cabeza : AnilloNV{X} -> X$Elt .
        op esVacio? : Anillo{X} -> Bool .
        op aLaCola : X$Elt Anillo{X} -> Anillo{X} .
        op elimCola : Anillo{X} -> Anillo{X} .
        op cola : AnilloNV {X} -> X$Elt .

        var A : Anillo{X} .
        vars E E2 : X$Elt .

        eq eliminar(crear) = crear .
        eq eliminar(insertar(E, A)) = A .

        eq cabeza(insertar(E, A)) = E .

        eq esVacio?(crear) = true .
        eq esVacio?(insertar(E, A)) = false .

        eq cola(insertar(E, crear)) = E .
        eq cola(insertar(E, insertar(E2, A))) = cola(insertar(E2, A)) .

        eq elimCola(crear) = crear .
        eq elimCola(insertar(E, crear)) = crear .
        eq elimCola(insertar(E, insertar(E2, A))) = insertar(E, elimCola(insertar(E2, A))) .

        eq aLaCola(E, crear) = insertar(E, crear) .
        eq aLaCola(E, insertar(E2, A)) = insertar(E2, aLaCola(E, A)) .

        eq rotarDch(crear) = crear .
        eq rotarDch(insertar(E, A)) = aLaCola(E, A) .

        eq rotarIzq(crear) = crear .
        eq rotarIzq(insertar(E, A)) = insertar(cola(insertar(E, A)), elimCola(insertar(E, A))) .
endfm

Cola de prioridades.

Una cola de prioridades es una estructura de datos en la que los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad, se atenderán de modo convencional según la posición que ocupen.

Implementacion en Java

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

Caracteristicas Generales:

Este tipo especial de colas tienen las mismas operaciones que las colas , pero con la condición de que los elementos se atienden en orden de prioridad.
Ejemplos de la vida diaria serían la sala de urgencias de un hospital, ya que los enfermos se van atendiendo en función de la gravedad de su enfermedad.
Entendiendo la prioridad como un valor numérico y asignando a altas prioridades valores pequeños, las colas de prioridad nos permiten añadir elementos en cualquier orden y recuperarlos de menor a mayor.

BiCola:

La bicola o doble cola es un tipo de cola especial que permiten la inserción y eliminación de elementos de ambos extremos de la cola.
Puede representarse a partir de un vector y dos índices, siendo su representación más frecuente una lista circular doblemente enlazada.
Todas las operaciones de este tipo de datos tienen coste constante.

Anexo Video informativo acerca de colas en java  :D

Implementacion en Java

 

// ArrayCircularQueue.java

package com.javajeff.cds;

public class ArrayCircularQueue implements Queue {
private int front = 0, rear = 0;
private Object [] queue;

public ArrayCircularQueue (int maxElements) {
queue = new Object [maxElements];
}

public void insert (Object o) {
int temp = rear;
rear = (rear + 1) % queue.length;
if (front == rear) {
rear = temp;
throw new FullQueueException ();
}
queue [rear] = o;
}

public boolean isEmpty () {
return front == rear;
}

public boolean isFull () {
return ((rear + 1) % queue.length) == front;
}

public Object remove () {
if (front == rear)
throw new EmptyQueueException ();
front = (front + 1) % queue.length;
return queue [front];
}
}