Contenido:

COLAS

Temas a Exponer:
Implementaciones
Operaciones
Ejemplos

Qu es 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. Las colas se utilizan en sistemas informticos, transportes y operaciones de
investigacin (entre otros), dnde los objetos, personas o eventos son tomados como
datos que se almacenan y se guardan mediante colas para su posterior procesamiento.
Usos concretos de la cola
La utilizacin de este mtodo programtico es que slo podemos acceder al primer y al
ltimo elemento de la estructura, de tal manera que los elementos slo se pueden
eliminar por el principio y slo se pueden aadir por el final de la cola.
Ejemplos de colas en la vida real seran: personas comprando en un supermercado,
esperando para entrar a ver un partido de bisbol, esperando en el cine para ver una
pelcula, una pequea peluquera, etc. La idea esencial es que son todas lneas de
espera.

Representacin de las colas

Un elemento se inserta en la cola (parte final) de la lista y se suprime o elimina por la
frente (parte inicial, cabeza) de la lista. Las aplicaciones utilizan una cola para
almacenar elementos en su orden de aparicin o concurrencia.

Los elementos se eliminan (se quitan) de la cola en el mismo orden en que se

almacenan y, por consiguiente, una cola es una estructura de tipoFIFO (first-iidfirs-out,
primero en ciitrar//?primero en salir o bienprimero en llegar/primero en ser servido).
Las colas se representan por listas enlazadas o por arrayas. Se necesitan dos
punteros: frente (f) y final(r), y la lista o arraya de n elementos (LONGMAX).

Operaciones Bsicas de las colas

Las operaciones bsicas de las colas son:
Crear: se crea la cola vaca.
Encolar (aadir, entrar, push): se aade un elemento a la cola. Se aade al final de
esta.
Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el
primer elemento que entr.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el
primero elemento que entr.
TIPOS DE COLAS
Cola circular o anillo: Una cola circular o anillo es una estructura de datos en la que los
elementos estn de forma circular y cada elemento tiene un sucesor y un predecesor.
Losmostrada
elementos
pueden
y eliminarse
nicamente desde la cabeza
En la figura
muestra
una colaconsultarse,
circular con un aadirse
solo dato almacenado.
La
anillo
es en
una
posicin
distinguida.
Esta
avanza
variable del
final
es la que
posicin
donde
se hizo la
ltima insercin.
Despus
queen el sentido de las agujas del
se ha producido
reloj. una insercin, final se mueve circularmente a la derecha. La
implementacin del movimiento circular se realiza utilizando la teda de los
restos:
Mover final adelante -( final + 1) R MaxTdmQ
Mover cabeza adelante cabeza

(frente i 1) 'o MdxTamQ

Cola de prioridades:
Una cola de prioridades se utiliza para que 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.
Este tipo especial de colas tienen las mismas operaciones que las colas, pero con la
condicin de que los elementos se atienden en orden de prioridad.
Ejemplos de la vida diaria seran la sala de urgencias de un hospital, ya que los enfermos se
van atendiendo en funcin de la gravedad de su enfermedad.
Estas colas se dividen en dos tipos
*Colas de prioridades con ordenamiento ascendente: en ellas los elementos se insertan de
forma arbitraria, pero a la hora de extraerlos, se extrae el elemento de menor prioridad.
*Colas de prioridades con ordenamiento descendente: son iguales que las colas de
prioridad con ordenamiento ascendente, pero al extraer el elemento se extrae el de mayor
prioridad.

Consideremos el siguiente ejemplo como un numero de 15 hijos y se ordena segur la

prioridad de: como es mayor que, se intercambia con este, y como es mayor que,
tambin se intercambia con este, y el proceso termina porque es menor que.

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:

Existen dos tipos de la doble cola:

Doble cola de entrada restringida: acepta inserciones solo al final de la cola.

Doble cola de salida restringida: acepta eliminaciones solo al frente de la cola.

IMPLEMENTACION DE COLAS
Esta implementacin es esttica, es decir, da un tamao mximo fijo a la cola. No se
incluye comprobacin de errores dentro del encolado y el desencolado, pero se
implementan como funciones aparte.
Por qu un array circular? Qu es eso? Como se aprecia en la implemetacin de las pilas,
los elementos se quitan y se ponen sobre la cima, pero en este caso se introducen por un
sitio y se quitan por otro.
Podra hacerse con un array secuencial, como se muestra en las siguientes figuras.
'Entrada' es la posicin de entrada a la cola, y 'Salida' por donde salen.
En esta primera figura se observa que se han introducido tres elementos: 3, 1 y 4 (en ese
orden):
se desencola, obteniendo un 3:

se encola un 7:

Primera versin:
Esta versin requiere el uso de la operacin mdulo de la divisin para determinar la
siguiente posicin en el array.
Por ejemplo, supngase un array de N = 2 elementos, contando desde 0 hasta 1. Suponer
que entrada = 0, salida = 1; Para determinar la posicin siguiente del ndice i en el array se
procede as:
i <- (i+1) Mod N
siendo Mod la operacin resto de la divisin entera. Asi:
- sustituyendo i por salida se determina que salida = 0.
- sustituyendo i por entrada se determina que entrada = 1.
si entrada = 1, salida = 2, entonces:
- sustituyendo i por salida se determina que salida = 1.
- sustituyendo i por entrada se determina que entrada = 2.
De esta manera se van dando vueltas sobre el array. La lgica es la siguiente:
Para encolar: se avanza el ndice entrada a la siguiente posicin, y se encola en la posicin
que apunte ste.
Para desencolar: el elemento desencolado es el que apunta el ndice salida, y posteriormente
se avanza salida a la siguiente posicin.
Cola vaca: la cola est vaca si el elemento siguiente a entrada es salida, como sucede en el
ejemplo anterior.

Cola vaca:

Se encola un 3.

Se desencola el 3; ahora se tiene una cola vaca.

Se encolan el 5 y el 7. Se obtiene una cola llena.

Si se desencola se obtiene el 5. Si en lugar de desencolar se encola un elemento

cualquiera se obtiene una cola vaca!.
- Declaracin:
struct tcola
{
int entrada, salida;
int elementos[MAX_COLA];
};
- Funcin que devuelve la posicin siguiente a i en el
array circular.
int siguiente(int i)
{
return ((i+1) % MAX_COLA);
}

- Creacin:
void crear(struct tcola *cola)
{
cola->salida = 0;
cola->entrada = MAX_COLA - 1;
}
- Funcin que devuelve verdadero si la cola est vaca, cosa que ocurre cuando el
siguiente tras entrada es salida:
int vacia(struct tcola *cola)
{
return (siguiente(cola->entrada) == cola->salida);
}
- Funcin que devuelve verdadero si la cola est llena, caso que se da cuando el
siguiente elemento que sigue a entrada es salida:
int llena(struct tcola *cola)
{
return (siguiente(siguiente(cola->entrada)) == cola->salida);
}

- Encolado:
void encolar(struct tcola *cola, int elem)
{
cola->entrada = siguiente(cola->entrada);
cola->elementos[cola->entrada] = elem;
}
- Desencolado:
void desencolar(struct tcola *cola, int *elem)
{
*elem = cola->elementos[cola->salida];
cola->salida = siguiente(cola->salida);
}

Segunda versin:
En este caso se omite la funcin siguiente, y se aprovechan todos los elementos. Sin
embargo se contabiliza en una variable el nmero de elementos que hay en un momento
dado en la cola. Esta implementacin es parecida a la secuencial, pero vigilando que los
ndices no se pasen de rosca.
Como se determina la siguiente posicin? Se avanza una posicin, y si llega al lmite del
array el ndice se actualiza al primer elemento. La lgica es la siguiente:
Para encolar: se encola en la posicin indicada por entrada, y se avanza una posicin.
Para desencolar: el elemento desencolado es el que apunta el ndice salida, y
posteriormente se avanza salida a la siguiente posicin.
Cola vaca: la cola est vaca si el nmero de elementos es cero.
Cola llena: la cola est llena si el nmero de elementos es el mximo admitido.

- Declaracin:
struct tcola
{
int elems;
int entrada, salida;
int elementos[MAX_COLA];
};
- Creacin:
void crear(struct tcola *cola)
{
cola->elems = cola->salida = cola->entrada = 0;
}
- Funcin que devuelve verdadero si la cola est
vaca:
int vacia(struct tcola *cola)
{
return (cola->elems == 0);

- Funcin que devuelve verdadero si la cola est llena:

int llena(struct tcola *cola)
{
return (cola->elems == MAX_COLA);
}
- Encolado:
void encolar(struct tcola *cola, int elem)
{
cola->elems++;
cola->elementos[cola->entrada++] = elem;
if (cola->entrada == MAX_COLA)
cola->entrada = 0;
}

- Desencolado:
void desencolar(struct tcola *cola, int *elem)
{
cola->elems--;
*elem = cola->elementos[cola->salida++];
if (cola->salida == MAX_COLA)
cola->salida = 0;
}

Implementacin mediante lista enlazada

Para hacer la implementacin se utilizar una lista circular sin cabecera.
La cola estar inicialmente vaca. Cuando se aadan elementos el puntero que mantiene
la cola apunta al ltimo elemento introducido, y el siguiente elemento al que apunta es
al primero que est esperando para salir.
- Cmo encolar?. Se crea el nuevo elemento, se enlaza con el primero de la cola. Si no
est vaca hay que actualizar el enlace del, hasta el momento de la insercin, ltimo
elemento introducido. Por ltimo se actualiza el comienzo de la cola, est vaca o no.
- Cmo desencolar?. Si tiene un slo elemento se borra y se actualiza el puntero a un
valor nulo. Si tiene dos o ms elementos entonces se elimina el primero y el ltimo
apuntar al segundo.
Ejemplo grfico de encolado. Partiendo de una cola que tiene el elemento 3, se van
aadiendo el 5 y el 7 (observar de izquierda a derecha). A la hora de desencolar se
extrae el siguiente al que apunta Cola.

Ejemplo grfico de desencolado. Partiendo de la cola formada anteriormente, se han

quitado los dos primeros elementos introducidos

- Declaracin:
struct tcola
{
int clave;
struct tcola *sig;
};
- Creacin:
void crear(struct tcola **cola)
{
*cola = NULL;
}

- Funcin que devuelve cierto si la cola est vaca:

int vacia(struct tcola *cola)
{
return (cola == NULL);
}
- Encolado:
void encolar(struct tcola **cola, int elem)
{
struct tcola *nuevo;
nuevo = (struct tcola *) malloc(sizeof(struct
tcola));
nuevo->clave = elem;
if (*cola == NULL)
nuevo->sig = nuevo;
else {
nuevo->sig = (*cola)->sig;
(*cola)->sig = nuevo;
}
(*cola) = nuevo;
}

- Desencolado:
void desencolar(struct tcola **c1, int *elem)
{
struct tcola *aux;
*elem = (*c1)->sig->clave;
if ((*c1) == (*c1)->sig) {
free(*c1);
*c1 = NULL;
}
else {
aux = (*c1)->sig;
(*c1)->sig = aux->sig;
free(aux);
}
}

Gracias por su atencin