¿Qué es una Cola?

Una cola es una estructura de datos lineal que sigue el principio FIFO (First In, First Out), es decir, el primer elemento en entrar es el primero en salir. Esto es similar a una fila en una tienda o en un banco, donde la primera persona en llegar es la primera en ser atendida.

Características de una Cola:

FIFO (First In, First Out): El primer elemento en ser añadido es el primero en ser removido.
Operaciones Básicas:
- Enqueue: Añadir un elemento al final de la cola.
- Dequeue: Remover el elemento del frente de la cola.
- Front: Obtener el elemento del frente sin removerlo.
- IsEmpty: Verificar si la cola está vacía.
- Size: Obtener el número de elementos en la cola.

Ejemplo de Cola en la Vida Real

Imagina una fila de personas esperando para comprar boletos en una taquilla. La primera persona en la fila es la primera en ser atendida y salir de la fila, mientras que las nuevas personas se añaden al final de la fila.

Representación de una Cola

Las colas pueden ser representadas de varias maneras en la programación, las más comunes son:

Usando Arrays
Usando Listas Enlazadas

Representación con Arrays

En una implementación con arrays, se utilizan dos índices para rastrear el frente y el final de la cola. Aquí hay un ejemplo básico en Python:

class Cola:
    def __init__(self, capacidad):
        self.capacidad = capacidad
        self.cola = [None] * capacidad
        self.frente = 0
        self.final = -1
        self.tamano = 0

    def is_empty(self):
        return self.tamano == 0

    def is_full(self):
        return self.tamano == self.capacidad

    def enqueue(self, item):
        if self.is_full():
            print("La cola está llena")
            return
        self.final = (self.final + 1) % self.capacidad
        self.cola[self.final] = item
        self.tamano += 1
        print(f"Enqueued: {item}")

    def dequeue(self):
        if self.is_empty():
            print("La cola está vacía")
            return None
        item = self.cola[self.frente]
        self.cola[self.frente] = None
        self.frente = (self.frente + 1) % self.capacidad
        self.tamano -= 1
        print(f"Dequeued: {item}")
        return item

    def front(self):
        if self.is_empty():
            print("La cola está vacía")
            return None
        return self.cola[self.frente]

    def size(self):
        return self.tamano

Explicación del Código

Inicialización: Se define la capacidad de la cola y se inicializan los índices frente y final, así como el tamaño de la cola.
is_empty: Verifica si la cola está vacía.
is_full: Verifica si la cola está llena.
enqueue: Añade un elemento al final de la cola. Si la cola está llena, imprime un mensaje de error.
dequeue: Remueve el elemento del frente de la cola. Si la cola está vacía, imprime un mensaje de error.
front: Devuelve el elemento del frente sin removerlo.
size: Devuelve el número de elementos en la cola.

Representación con Listas Enlazadas

Otra forma de implementar una cola es usando listas enlazadas. Aquí hay un ejemplo básico en Python:

class Nodo:
    def __init__(self, dato):
        self.dato = dato
        self.siguiente = None

class ColaEnlazada:
    def __init__(self):
        self.frente = None
        self.final = None
        self.tamano = 0

    def is_empty(self):
        return self.frente is None

    def enqueue(self, item):
        nuevo_nodo = Nodo(item)
        if self.final:
            self.final.siguiente = nuevo_nodo
        self.final = nuevo_nodo
        if not self.frente:
            self.frente = nuevo_nodo
        self.tamano += 1
        print(f"Enqueued: {item}")

    def dequeue(self):
        if self.is_empty():
            print("La cola está vacía")
            return None
        item = self.frente.dato
        self.frente = self.frente.siguiente
        if not self.frente:
            self.final = None
        self.tamano -= 1
        print(f"Dequeued: {item}")
        return item

    def front(self):
        if self.is_empty():
            print("La cola está vacía")
            return None
        return self.frente.dato

    def size(self):
        return self.tamano

Explicación del Código

Nodo: Clase que representa un nodo en la lista enlazada.
ColaEnlazada: Clase que representa la cola usando nodos enlazados.
is_empty: Verifica si la cola está vacía.
enqueue: Añade un nuevo nodo al final de la cola.
dequeue: Remueve el nodo del frente de la cola.
front: Devuelve el dato del nodo del frente sin removerlo.
size: Devuelve el número de elementos en la cola.

Conclusión

En esta lección, hemos aprendido qué es una cola, sus características principales y cómo se puede representar tanto con arrays como con listas enlazadas. En las próximas lecciones, profundizaremos en las operaciones básicas con colas y sus aplicaciones en la programación.

Resumen:

Una cola es una estructura de datos que sigue el principio FIFO.
Las operaciones básicas incluyen enqueue, dequeue, front, is_empty y size.
Las colas pueden implementarse usando arrays o listas enlazadas.

En la siguiente lección, exploraremos las operaciones básicas con colas en mayor detalle.

Introducción a las Colas

¿Qué es una Cola?

Características de una Cola:

Ejemplo de Cola en la Vida Real

Representación de una Cola

Representación con Arrays

Explicación del Código

Representación con Listas Enlazadas

Explicación del Código

Conclusión

Curso de Estructuras de Datos

Módulo 1: Introducción a las Estructuras de Datos

Módulo 2: Listas

Módulo 3: Pilas

Módulo 4: Colas

Módulo 5: Árboles

Módulo 6: Grafos

Módulo 7: Conclusiones y Recursos Adicionales