Tipos de Colas

Qu es una cola?

Una cola es una estructura de datos, caracterizada por ser una
secuencia de elementos en la que la operacin de insercin push se
realiza por un extremo y la operacin de extraccin pop por el otro.
Tambin se le llama estructura FIFO (del ingls First In First Out),
debido a que el primer elemento en entrar ser tambin el primero en
salir.

Tipos de Colas
Colas de prioridad: En ellas, los elementos se atienden en el orden
indicado por una prioridad asociada a cada uno. Si varios elementos
tienen la misma prioridad, se atendern de modo convencional
segn la posicin que ocupen. Hay 2 formas de implementacin:
A. Aadir un campo a cada nodo con su prioridad. Resulta
conveniente mantener la cola ordenada por orden de prioridad.
B. Crear tantas colas como prioridades haya, y almacenar cada
elemento en su cola.

Bicolas: son colas en donde los nodos se pueden aadir y quitar por
ambos extremos; se les llama DEQUE (Double Ended QUEue). Para
representar las bicolas lo podemos hacer con un array circular con
Inicio y Fin que apunten a cada uno de los extremos. Hay variantes:

A. Bicolas de entrada restringida: Son aquellas donde la insercin
slo se hace por el final, aunque podemos eliminar al inicio
al final.
B. Bicolas de salida restringida: Son aquellas donde slo se
elimina por el final, aunque se puede insertar al inicio y al final.



Cola simple: Estructura lineal donde los elementos salen en
el mismo orden en que llegan.

Cola circular: Representacin lgica de una cola simple en un
arreglo.

Las colas pueden ser representadas en arreglos de
una dimensin (vector) manteniendo dos variables
que indiquen el FRENTE y FINAL de los elementos
de la cola.
A F S D Z
Frente Final
0 1 2 3 4 5
Representacin usando arreglos
Cuando la cola esta vaca las variables frente y final son
nulos y no es posible remover elementos.
Cuando la cola esta llena ( frente = 0 y final = n-1) no es
posible insertar elementos nuevos a la cola.
Cuando se remueven elementos el frente puede
incrementarse para apuntar al siguiente elemento de la
cola (implementacion con frente movil) o los elementos
en la cola pueden desplazarse una posicion adelante
(implementacin con frente fijo)
Recuperacin de espacio: Cuando no hay espacios libres
al final del arreglo los elementos pueden ser
desplazados para desocupar posiciones en un extremo
del arreglo o se puede manejar una estructura circular.
Ejemplo: Suponer que usamos un arreglo de 5
posiciones. Usando la representacin de frente fijo y
frente movible.
A B C
Frente
Final
Al remover un elemento:
B C
Frente Final
B C
Frente Final
Frente fijo Frente movible
Insertar elemento D:
B C D
Frente Final
B C
Frente Final
B C D
B C
Frente Final
Frente Final
Insertar elemento E:
B C D E
Frente Final
Insertar elemento F:
B C D E F
Frente Final
Insertar elemento G: Error: Cola llena!!!!
B C D E
Frente Final
B C D E F
Frente Final
Cola Circular
Es una representacin
lgica de la cola en un
arreglo.
El frente y final son
movibles.
Cuando el frente o final
llegan al extremo se
regresan a la primera
posicin del arreglo.
C D E
Frente Final
F C D E
Frente Final
C D
Frente
Final
B C D
Frente Final
Remover
Insertar E
Insertar F
Cola
inicial
Representacin de colas:
Usando memoria esttica: arreglos con tamao fijo y
frente fijo o movible o represntacin circular.






Usando memoria dinmica: Listas ligadas.

B C D E F Frente
Final
0 1 2 3 4
B C D
Frente
Final
E F
Interfase de un TDA llamado ICola:

interface ICola{
public boolean llena();
public boolean vacia();
public void insertar (Object elem);
public Object eliminar();
}

Implementacin de una cola:
class Cola<T> implements ICola<T> {
private T[] cola;
private int frente = -1;
private int fin = -1;
private int size;

public Cola(int s){
size = s-1;
cola = new T[s];
}
public boolean vacia(){
return (frente == -1);
}
public boolean llena(){
return ( fin == size );
}
public void insertar( T elem) {
...
}
public T eliminar(){

}

}
class Cola implements ICola {
private Object[] cola;
private int frente = -1;
private int fin = -1;
private int size;

public Cola(int s){
size = s-1;
cola = new Object[s];
}
public boolean vacia(){
return (frente == -1);
}
public boolean llena(){
return ( fin == size );
}
public void insertar( Object elem) {
if ( frente == -1 )
frente ++;
else
if ( fin == size)
ERROR Cola Llena!
fin ++;
cola[fin]=elem;
}
}
public Object eliminar(){

}
}
Implementacion usando
Object
Implementacion usando
parametros de tipo