Una cola (queue en inglés) es una estructura de datos lineal que sigue el principio FIFO (First In, First Out), lo que significa que el primer elemento en entrar es el primero en salir. Este comportamiento es similar a una fila en un banco o supermercado: el primer cliente en la fila es el primero en ser atendido.

Las colas son útiles para modelar situaciones donde el orden de llegada es importante, como en sistemas de impresión, tareas en segundo plano o la gestión de procesos en sistemas operativos.

Estructura de una Cola

La cola tiene dos operaciones principales:

Enqueue (Agregar): Inserta un elemento al final de la cola.
Dequeue (Eliminar): Remueve el elemento del frente de la cola.
Además, algunas colas ofrecen operaciones adicionales:

Peek (Consultar): Permite ver el elemento al frente sin eliminarlo.
IsEmpty (Vacía): Verifica si la cola no tiene elementos.

Tipos de Colas

Existen variaciones de la cola estándar según las necesidades del sistema:

Cola Simple: Sigue el principio FIFO.
Cola Circular: Reutiliza el espacio cuando los elementos al frente son removidos, evitando un crecimiento innecesario.
Cola de Prioridad: Los elementos tienen una prioridad, y los de mayor prioridad se procesan primero, independientemente de su orden de llegada.
Cola Doble (Deque): Permite agregar y eliminar elementos tanto al frente como al final.

Las colas son una estructura fundamental en programación que modela el flujo natural de procesamiento basado en el orden de llegada. Desde la cola simple hasta las variantes más complejas como colas de prioridad o circulares, esta estructura de datos es esencial para resolver problemas en sistemas en tiempo real, algoritmos y procesamiento en segundo plano. Comprender cómo funcionan y cómo implementarlas en diferentes lenguajes ampliará tu capacidad para diseñar soluciones eficientes y flexibles.

Ejemplos de Colas en Diferentes Lenguajes

A continuación, veremos cómo implementar una cola en varios lenguajes.

JavaScript
En JavaScript, podemos usar arrays para simular una cola con los métodos push y shift.

class Cola {
  constructor() {
    this.elementos = [];
  }

  enqueue(dato) {
    this.elementos.push(dato); // Agregar al final
  }

  dequeue() {
    return this.elementos.shift(); // Remover del frente
  }

  peek() {
    return this.elementos[0]; // Consultar el frente
  }

  isEmpty() {
    return this.elementos.length === 0; // Verificar si está vacía
  }
}

const cola = new Cola();
cola.enqueue(10);
cola.enqueue(20);

console.log(cola.peek()); // Muestra 10
console.log(cola.dequeue()); // Elimina y muestra 10
console.log(cola.isEmpty()); // Muestra false

PHP
En PHP, las colas pueden implementarse fácilmente utilizando arrays.

class Cola {
    private $elementos = [];

    public function enqueue($dato) {
        array_push($this->elementos, $dato); // Agregar al final
    }

    public function dequeue() {
        return array_shift($this->elementos); // Remover del frente
    }

    public function peek() {
        return reset($this->elementos); // Consultar el frente
    }

    public function isEmpty() {
        return empty($this->elementos); // Verificar si está vacía
    }
}

$cola = new Cola();
$cola->enqueue(10);
$cola->enqueue(20);

echo $cola->peek(); // Muestra 10
echo $cola->dequeue(); // Elimina y muestra 10
echo $cola->isEmpty(); // Muestra false

C#
Tiene una clase nativa llamada Queue en System.Collections.Generic.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Queue<int> cola = new Queue<int>();
        cola.Enqueue(10);
        cola.Enqueue(20);

        Console.WriteLine(cola.Peek()); // Muestra 10
        Console.WriteLine(cola.Dequeue()); // Elimina y muestra 10
        Console.WriteLine(cola.Count == 0); // Verifica si está vacía: false
    }
}

Java
Puedes usar la interfaz Queue o clases como LinkedList y PriorityQueue.

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> cola = new LinkedList<>();
        cola.add(10);
        cola.add(20);

        System.out.println(cola.peek()); // Muestra 10
        System.out.println(cola.poll()); // Elimina y muestra 10
        System.out.println(cola.isEmpty()); // Muestra false
    }
}

C
Las colas se pueden implementar usando arrays y punteros.

#include <stdio.h>
#include <stdlib.h>

#define MAX 100

typedef struct {
    int elementos[MAX];
    int frente, final;
} Cola;

void enqueue(Cola* cola, int dato) {
    if (cola->final == MAX - 1) {
        printf("Cola llena\n");
        return;
    }
    cola->elementos[++cola->final] = dato;
}

int dequeue(Cola* cola) {
    if (cola->frente > cola->final) {
        printf("Cola vacía\n");
        return -1;
    }
    return cola->elementos[cola->frente++];
}

int peek(Cola* cola) {
    if (cola->frente > cola->final) {
        printf("Cola vacía\n");
        return -1;
    }
    return cola->elementos[cola->frente];
}

int main() {
    Cola cola = {{0}, 0, -1};
    enqueue(&cola, 10);
    enqueue(&cola, 20);

    printf("%d\n", peek(&cola)); // Muestra 10
    printf("%d\n", dequeue(&cola)); // Elimina y muestra 10
    printf("%d\n", cola.frente > cola.final); // Verifica si está vacía: 0 (false)
    return 0;
}

C++
Tiene una clase std::queue en su biblioteca estándar.

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> cola;
    cola.push(10);
    cola.push(20);

    cout << cola.front() << endl; // Muestra 10
    cola.pop();

    cout << cola.front() << endl; // Muestra 20
    cout << cola.empty() << endl; // Verifica si está vacía: 0 (false)
    return 0;
}