Introducción.

Las colas son listas lineales de información a las que se accede de una manera específica
utilizando la técnica conocida como "first-in, first-out" o FIFO (primero en entrar, primero
en salir). Esto significa que el primer dato que ingresa es también el primer dato que se
retira; en las colas no se permite el acceso aleatorio a ningún elemento en particular. En
la vida cotidiana, tenemos ejemplos como la cola en el cine o en la parada del autobús: el
primero en llegar es el primero en entrar. También encontramos colas en los puntos de
pago de los supermercados: el cliente que llega primero es el primero en ser atendido.
Una cola es un tipo de lista lineal en la que los elementos se retiran del principio de la
lista, en el frente (o cabeza de la cola), y las inserciones se realizan al final de la lista.

Operaciones básicas.
•Acceder al primer elemento de la cola (apuntado por inicio).
• Anexar, insertar, push un elemento al final de la cola, proceso llamado enqueue
(encolar).
• Retirar, sacar, pop un elemento de la cola (apuntado por inicio), proceso llamado
dequeue (decolar). • Verificar el estado de la cola (llena o vacía).
• Crear: se crea la cola vacía.
• Retornar el primer elemento que entró en la cola.
• Verificar el estado de la cola (llena o vacía).
Características.
Orden FIFO (First-In, First-Out): Los elementos se procesan en el mismo orden en que
fueron agregados a la cola, es decir, el primero en entrar es el primero en salir.

Estructura Lineal: Una cola es una estructura de datos lineal, lo que significa que los
elementos se organizan en una secuencia unidimensional.

Acceso Limitado: El acceso a los elementos de una cola está limitado. Solo se puede
acceder al elemento en la parte frontal (cabeza) de la cola.

Operaciones Básicas: Las operaciones comunes en una cola incluyen Enqueue (para
agregar elementos al final), Dequeue (para eliminar y obtener el elemento en la parte
frontal), Front (para obtener el elemento en la parte frontal sin eliminarlo), isEmpty (para
verificar si la cola está vacía) y Size (para obtener el número de elementos en la cola).

Implementación con Listas Enlazadas o Arreglos: Las colas se pueden implementar

utilizando listas enlazadas (linked lists) o arreglos (arrays). La elección depende de los
requisitos específicos y del rendimiento deseado.

Estructura Dinámica: Las colas pueden crecer o reducirse dinámicamente a medida que
se agregan o eliminan elementos.

Uso en Aplicaciones: Las colas se utilizan en una variedad de aplicaciones, como la

gestión de tareas en sistemas operativos, el procesamiento de pedidos en aplicaciones de
comercio electrónico, la impresión de documentos en impresoras, entre otros.

Eficiencia en las Operaciones: Las operaciones Enqueue y Dequeue son eficientes en

una cola implementada con una lista enlazada, generalmente con complejidad O(1).

Capacidad Limitada (Opcional): Algunas colas pueden tener una capacidad máxima
predefinida, lo que significa que no se pueden agregar más elementos una vez que la cola
está llena.

Elementos de Diferentes Tipos: Los elementos de una cola no necesariamente tienen que
ser del mismo tipo; pueden ser de cualquier tipo de dato.
Aplicaciones
1. Sistemas operativos.
2. Gestión de tareas y listas de pendientes.
3. Colas de impresión.
4. Enrutamiento de datos en redes.
5. Gestión de recursos compartidos.
6. Procesamiento de eventos en tiempo real.
7. Manejo de solicitudes de servicio al cliente.
8. Simulaciones y modelado de sistemas.
9. Almacenamiento temporal de datos antes de su procesamiento.
10. Control de flujo de datos en sistemas de procesamiento por lotes

Las colas, al igual que las pilas, pueden implementarse utilizando una estructura estática,
como los arrays, o una estructura dinámica, como las listas enlazadas o los vectores. En
esta sección, se considera la implementación con arrays. Para crear una cola, se requiere
un array para almacenar los elementos de la cola y dos marcadores o punteros que
mantengan las posiciones del frente y el final de la cola. El primer marcador apunta a la
posición de la cabeza de la cola, mientras que el segundo apunta al primer espacio vacío
después del final de la cola.
Cuando se añade un elemento a la cola, se verifica si el marcador del final apunta a una
posición válida y, en ese caso, se agrega el elemento a la cola y se incrementa el
marcador del final en 1. En el proceso de eliminación de un elemento de la cola, se realiza
una comprobación para determinar si la cola está vacía. Si no lo está, se recupera el
elemento de la posición señalada por el marcador de la cabeza y se incrementa en 1
dicho marcador.

La operación de añadir un elemento a la cola comienza en la posición 0 del marcador del

final, y cada vez que se añade un nuevo elemento, el marcador del final se incrementa en
1. Por otro lado, la extracción de un elemento se efectúa desde el extremo contrario,
utilizando el marcador del frente, y cada vez que se extrae un elemento, el marcador del
frente avanza una posición.

Es importante destacar que el avance lineal de los marcadores del frente y el final puede
generar problemas, ya que puede dejar espacios vacíos en el array, especialmente a la
izquierda del marcador del frente. En ocasiones, el marcador del final puede llegar al
índice más alto del array sin posibilidad de añadir nuevos elementos, a pesar de que aún
existan posiciones libres a la izquierda del marcador del frente.

Una alternativa consiste en mantener fijo el frente de la cola al comienzo del array y
mover todos los elementos de la cola una posición cada vez que se retira un elemento.
Estos problemas quedan resueltos considerando el array como circular,
Código.
Package TipoCola;
Public class ColaLineal {
Private static fin int MAXTAMQ=39;
Protected int frente;
Protected int fin;
Protected TipoDeDato[] ListaCola;
Public ColaLineal(){
Frente=0;
Fin=-1;
listaCola=new TipoDeDato [MAXTAMQ];
}
//Operaciones para la modificación de la cola.
Public void insrtar(TipoDeDato elemento) throws exception {
If(!colaLLena()){
listaCola[++fin]=elemento;
}
Else{
Throw new Expection(“Cola llena”)
}
}
Public TipoDeDato quitar() throws Exception{
Of(!colaVacia()){
Return listaCola[frente++];
}
Else {
Throw new Exception (“Cola vacia”);
}
//vaciar la cola
Public void borrarCola(){
 Frente=0;
Fin=-1;
}
}
//acesso a la cola
Public TipoDeDato frentecola() throws Exception{
If(colaVacia()){
Return listaCola[frente];
}
Else{
Throw new Exception (“Cola vacia”);
}
}
//métodos de verificación del estado de la cola
Public boolean colaVacia(){
Return frente>fin;
}
Public boolean colaLlena(){
Return fin==MAXRAMQ-1;
}
}
Al realizar una cola por medio de un arreglo lineal es notablemente ineficiente, debido a
que se puede alcanzar la condición de la cola llena existiendo elemento del arreglo sin
ocupar.

Cola con array circular.

La sugerencia de desplazar los elementos restantes del array para llevar la cabeza de la
cola de nuevo al principio del array durante la operación de eliminación de un elemento
resulta ser una operación costosa en términos de tiempo de computadora, especialmente
cuando los datos almacenados en el array son estructuras de datos grandes. Una forma
más eficiente de representar una cola en un array es modelarla de manera que se
conecte el extremo final con el extremo de la cabeza. Este tipo de array se conoce como
un "array circular" y permite utilizar todas las posiciones del array para almacenar
elementos de la cola sin necesidad de desplazar elementos.
En un array circular de n elementos, el array se almacena en la memoria como un bloque
lineal de n elementos. Se requieren dos marcadores o punteros, uno llamado "frente" y
otro llamado "fin", para indicar la posición de la cabeza de la cola y la posición del último
elemento insertado en la cola, respectivamente. Cuando la cola está vacía, el puntero
"frente" siempre contiene la posición del primer elemento de la cola y avanza en el sentido
de las agujas del reloj. El puntero "fin" contiene la posición donde se agregó el último
elemento y también avanza en el sentido del reloj, circularmente hacia la derecha.

La implementación del movimiento circular se lleva a cabo utilizando la teoría de los

residuos, de manera que se generen índices desde 0 hasta MAXTAM-1 (el tamaño
máximo del array). Esto permite que la cola funcione eficientemente sin necesidad de
desplazar elementos.
Los algoritmos que formalizan la gestión de colas en un array circular deben incluir las
operaciones básicas del Tipo Abstracto de Datos (TAD) Cola, que implican las siguientes
tareas fundamentales:

Creación de una cola vacía: Se inicializa una cola vacía de modo que el puntero "fin"
apunte a una posición inmediatamente anterior al puntero "frente". Es decir, frente = 0 y
fin = MAXTAMQ - 1.

Comprobar si una cola está vacía: Se verifica si la cola está vacía comparando los
punteros "frente" y "fin" para ver si son adyacentes, lo que indica una cola vacía.

Comprobar si una cola está llena: Para distinguir entre una cola llena y una cola vacía, se
reserva una posición adicional en el array, de modo que la capacidad máxima de la cola
será MAXTAMQ - 1. La condición de cola llena se verifica comparando el puntero "frente"
con el siguiente elemento después del puntero "fin".
Poner un elemento en la cola: Si la cola no está llena, se avanza el puntero "fin" a la
siguiente posición (circularmente) y se asigna el elemento a esa posición.

Retirar un elemento de la cola: Si la cola no está vacía, se elimina el elemento de la

posición apuntada por "frente" y se avanza el puntero "frente" a la siguiente posición
(circularmente).

Obtener el elemento primero de la cola: Si la cola no está vacía, se obtiene el elemento

que se encuentra en la posición apuntada por "frente" sin eliminarlo de la cola.

Estas operaciones son esenciales para la gestión de colas implementadas en un array

circular, asegurando un uso eficiente de la estructura de datos sin necesidad de desplazar
elementos.

Código de una cola circular.

public class ColaCircular {

private int capacidad;

private int[] cola;
private int frente; // Puntero al frente de la cola
private int fin; // Puntero al final de la cola
private int tamañoActual;

// Constructor para inicializar la cola circular

public ColaCircular(int tamaño) {
capacidad = tamaño;
cola = new int[tamaño];
frente = -1;
fin = -1;
tamañoActual = 0;
}
// Comprobar si la cola está vacía
public boolean estaVacia() {
return tamañoActual == 0;
}

// Comprobar si la cola está llena

public boolean estaLlena() {
return tamañoActual == capacidad;
}

// Agregar un elemento a la cola

public void encolar(int elemento) {
if (!estaLlena()) {
if (frente == -1) {
frente = 0;
}
fin = (fin + 1) % capacidad;
cola[fin] = elemento;
tamañoActual++;
System.out.println("Se ha agregado el elemento " + elemento + " a la cola.");
} else {
System.out.println("La cola está llena. No se puede agregar más elementos.");
}
}

// Eliminar un elemento de la cola

public void desencolar() {
if (!estaVacia()) {
int elementoEliminado = cola[frente];
 if (frente == fin) {
frente = -1;
fin = -1;
} else {
frente = (frente + 1) % capacidad;
}
tamañoActual--;
System.out.println("Se ha eliminado el elemento " + elementoEliminado + " de la
cola.");
} else {
System.out.println("La cola está vacía. No se puede eliminar ningún elemento.");
}
}

// Obtener el elemento en el frente de la cola

public int obtenerFrente() {
if (!estaVacia()) {
return cola[frente];
} else {
System.out.println("La cola está vacía. No hay elemento en el frente.");
return -1; // Valor predeterminado en caso de cola vacía
}
}

// Obtener el tamaño actual de la cola

public int obtenerTamaño() {
return tamañoActual;
}

public static void main(String[] args) {

 ColaCircular cola = new ColaCircular(5);

cola.encolar(1);
cola.encolar(2);
cola.encolar(3);

System.out.println("Elemento en el frente de la cola: " + cola.obtenerFrente());

cola.desencolar();
cola.encolar(4);
cola.encolar(5);
cola.encolar(6); // Esto debería generar un mensaje de que la cola está llena.

while (!cola.estaVacia()) {
System.out.println("Elemento desencolado: " + cola.obtenerFrente());
cola.desencolar();
}
}
}
Bibliografía.
Hernández Bejarano, M. y Baquero Rey, L. E. (2022). Estructuras de datos:
fundamentación práctica. 1. Madrid, RA-MA Editorial. Recuperado de
https://elibro.net/es/ereader/cuautla/230581?page=2.

Zohonero Martínez, I. y Joyanes Aguilar, L. (2008). Estructuras de datos en Java. Madrid

etc, Spain: McGraw-Hill España. Recuperado de
https://elibro.net/es/ereader/cuautla/50117?page=326.