Estructuras de datos en Go: Colas

Las colas son una de las estructuras de datos más comunes y fundamentales. Se trata de una estructura de datos lineal, en la cual los elementos se agregan y se quitan en un orden específico. Esta estructura de datos se comporta como una fila real, en la cual los elementos se agregan a un "final" y se quitan desde el "comienzo". Esto significa que el primer elemento en ser agregado a la cola será el primero en ser removido. Debido a su simplicidad y al hecho de que los elementos se agregan y se quitan en orden, se puede utilizar para solucionar varios problemas de programación. Por ejemplo, una cola se puede usar para administrar una lista de trabajos en un sistema de computación. Esto significa que los trabajos que se agregan primero a la cola se procesan primero y los trabajos que se agregan después se procesan después.

Un poco de historia sobre las colas

La estructura de datos cola fue inventada por el matemático y científico francés Denis Diderot en 1765 como parte de su trabajo sobre el análisis numérico. En aquel entonces, se conocía como "Fila de trabajo", ya que fue utilizada para representar una lista de trabajos en un sistema de computación. Esta estructura de datos fue posteriormente utilizada por Edsger Dijkstra en el desarrollo de algoritmos para la programación de procesos concurrentes. Desde entonces, la estructura de datos cola se ha convertido en una estructura de datos fundamental, utilizada para solucionar una amplia variedad de problemas de programación.

Algunas características

Las colas son estructuras de datos lineales, en las cuales los elementos se agregan y se quitan en un orden específico.
Los elementos se agregan al "final" de la cola y se quitan desde el "comienzo".
La operación de inserción en una cola se conoce como "Encolar" (Enqueue) y la operación de remover un elemento se conoce como "Desencolar" (Dequeue).
Las colas son las únicas estructuras de datos en las cuales los elementos se agregan y se quitan en orden.
Las colas permiten el acceso a los elementos en orden, permitiendo que los elementos se procesen de acuerdo al orden en que fueron agregados.
Las colas se pueden implementar de manera estática (utilizando arreglos) o dinámica (utilizando listas ligadas).
Las colas son utilizadas para solucionar problemas en los cuales los elementos deben ser procesados en orden.
Las colas son uno de los algoritmos más utilizados para la programación de procesos concurrentes.
Las colas también se pueden utilizar para implementar un sistema de colas de trabajo, en el cual los trabajos se agregan a la cola y son procesados en orden.
Las colas se consideran una estructura de datos fundamental por su simplicidad y por la forma en que los elementos se agregan y se quitan en orden.

Entendiendo las colas mediante analogías:

En un supermercado, los clientes se agregan al final de la cola y se quitan desde el comienzo, permitiendo que sean atendidos en orden. Esta es una analogía perfecta de una cola, ya que los elementos se agregan al final de la cola y se quitan desde el comienzo.

En un banco, los clientes también se agregan al final de la cola y se quitan desde el comienzo. Esto permite que los clientes sean atendidos en el orden correcto. Esta es una buena analogía para ilustrar el comportamiento de una cola.

En una atracción del parque de diversiones, los visitantes se agregan al final de la cola y se quitan desde el comienzo. Esto permite que los visitantes sean atendidos en el orden correcto. Esta es otra buena analogía para explicar el comportamiento de una cola.

Colas en Go

Ahora Vamos a Go! y escribamos una cola:

// Declaramos una estructura Cola
type Cola struct {
    elementos []interface{}
}

// Agregamos un método Enqueue para agregar elementos al final de la cola
func (c *Cola) Enqueue(elemento interface{}) {
    c.elementos = append(c.elementos, elemento)
}

// Agregamos un método Dequeue para remover elementos desde el comienzo de la cola
func (c *Cola) Dequeue() interface{} {
    elemento := c.elementos[0]
    c.elementos = c.elementos[1:]
    return elemento
}

// Agregamos un método Peek para obtener información acerca del elemento que se encuentra al comienzo de la cola
func (c *Cola) Peek() interface{} {
    return c.elementos[0]
}

// Agregamos un método Len para obtener el número de elementos que se encuentran en la cola
func (c *Cola) Len() int {
    return len(c.elementos)
}

// Agregamos un método Clear para remover todos los elementos de la cola
func (c *Cola) Clear() {
    c.elementos = []interface{}{}
}

Algunos métodos adicionales

isEmpty

// Agregamos un método IsEmpty para verificar si la cola está vacía

func (c *Cola) IsEmpty() bool {
    return len(c.elementos) == 0
}

toString

// Agregamos un método ToString para imprimir la cola

func (c *Cola) ToString() string {
    resultado := "Cola: ["for _, elemento := range c.elementos {
        resultado += fmt.Sprintf("%v ", elemento)
    }

    resultado += "]"return resultado
}

Usando la estructura

Veamos un ejemplo de una cola de tres personas Sebas, Jill y Anastasia y usa cada uno de los metodos que hemos creado para mostrar como usarla

// Declarar una cola
var cola Cola

// Agregar elementos a la cola
cola.Enqueue("Sebas")
cola.Enqueue("Jill")
cola.Enqueue("Anastasia")

// Imprimir la cola
fmt.Println(cola.ToString()) // Cola: [Sebas Jill Anastasia]

// Obtener información de la cola
// Primer elemento de la cola
fmt.Println(cola.Peek()) // Sebas
// Número de elementos en la cola
fmt.Println(cola.Len()) // 3

// Remover elementos de la cola
// Primer elemento
fmt.Println(cola.Dequeue()) // Sebas
// Nuevo número de elementos
fmt.Println(cola.Len()) // 2
// Nueva cola
fmt.Println(cola.ToString()) // Cola: [Jill Anastasia]

// Verificar si la cola está vacía
fmt.Println(cola.IsEmpty()) // false

// Vaciar la cola
cola.Clear()
// Verificar si la cola está vacía
fmt.Println(cola.IsEmpty()) // true

Conclusiones

Las colas son una de las estructuras de datos más comunes y fundamentales, utilizada en una amplia variedad de problemas de programación. Esta estructura de datos se comporta como una fila real, en la cual los elementos se agregan al "final" y se quitan desde el "comienzo". Esto significa que el primer elemento en ser agregado a la cola será el primero en ser removido. Las colas también son una de las estructuras de datos más utilizadas para la programación de procesos concurrentes. Esta estructura de datos es extremadamente simple y fácil de usar, lo que la hace ideal para solucionar problemas en los cuales los elementos deben ser procesados en orden.

Ejercicios para practicar

A continuación te dejo un par de ejercicios para que practiques la estructura Cola (Queue) en Go y envies la solucioón como un Pull requeste a este repositorio:

Go Para Principiantes

Ejercicio 1:

Crea un programa en Go que simule una cola de un supermercado. El programa debe permitir a los usuarios encolarse, ver el elemento que se encuentra al comienzo de la cola y desencolarse. El programa debe además informar cuántos usuarios hay en la cola.

Ejercicio 2:

Crea un programa en Go que implemente un sistema de cola de trabajo para procesar archivos. El sistema debe permitir a los usuarios encolar archivos para su procesamiento, ver el archivo que se encuentra al comienzo de la cola y desencolar archivos una vez que se hayan procesado. El programa debe además informar cuántos archivos hay en la cola.