Sebastian Gomez

Apr 06, 2023

Estructuras de datos en Go: Dequeue

🚀 Estructuras de datos en Go: Dequeue 🚀

Las dequeues (🔄) o colas de doble extremo, son estructuras de datos versátiles que permiten insertar (➕) y eliminar (➖) elementos tanto por el frente (🔝) como por la parte trasera (🔚). En este post, exploraremos las principales características de esta estructura, su historia 📚 y algunos ejemplos de su uso en problemas de computación 💻.

🔍 ¿Qué es una "dequeue" (🔄)?

Una dequeue (🔄) es un tipo de estructura de datos que permite insertar (➕) y eliminar (➖) elementos tanto por el frente (🔝) como por la parte trasera (🔚). Esto la hace similar a una cola (🔜) o una pila (🔝), pero con la flexibilidad adicional de poder agregar o quitar elementos en ambos extremos. Esto hace que sea útil en muchos algoritmos y situaciones donde se requiera una estructura de datos que permita operaciones de inserción (➕) y eliminación (➖) eficientes en ambos extremos.

📚 Historia de las "dequeues" (🔄)

El concepto de una dequeue (🔄) probablemente haya sido desarrollado poco después de la invención de la computadora (💻). Sin embargo, la documentación escrita más antigua que se conoce sobre la estructura de datos dequeue data de la década de 1950 y se refiere a ella como una "cola circular doble" (↪️).

A partir de ahí, la estructura de datos dequeue ha sido ampliamente utilizada en diferentes ámbitos de la informática, desde la programación de sistemas hasta la investigación en inteligencia artificial (🧠) y algoritmos (🔢).

Ejemplo de código en Go

Aquí hay un ejemplo de código en Go que implementa una "dequeue" o cola de doble extremo:

package main

import (
	"fmt"
)

// Definimos una estructura de datos dequeue.
type Dequeue struct {
	items []int
	head  int
	tail  int
	count int
}

// Función para crear una nueva dequeue.
func NewDequeue() *Dequeue {
	return &Dequeue{
		items: make([]int, 0),
		head:  -1,
		tail:  -1,
		count: 0,
	}
}

// Función para insertar un elemento en el frente de la dequeue.
func (d *Dequeue) PushFront(item int) {
	if d.head == -1 {
		d.head = 0
		d.tail = 0
		d.items = append(d.items, item)
	} else {
		d.head--
		if d.head < 0 {
			d.head = len(d.items) - 1
		}
		d.items[d.head] = item
	}
	d.count++
}

// Función para insertar un elemento en la parte trasera de la dequeue.
func (d *Dequeue) PushBack(item int) {
	if d.head == -1 {
		d.head = 0
		d.tail = 0
		d.items = append(d.items, item)
	} else {
		d.tail++
		if d.tail == len(d.items) {
			d.tail = 0
		}
		d.items[d.tail] = item
	}
	d.count++
}

// Función para eliminar un elemento del frente de la dequeue.
func (d *Dequeue) PopFront() int {
	if d.head == -1 {
		return -1
	}

	item := d.items[d.head]
	d.head++
	if d.head == len(d.items) {
		d.head = 0
	}
	d.count--
	if
 d.count == 0 {
	  d.head = -1
	  d.tail = -1
       }
   
      return item
}

// Función para eliminar un elemento de la parte trasera de la dequeue.
func (d *Dequeue) PopBack() int {
if d.head == -1 {
return -1
}
item := d.items[d.tail]
d.tail--
if d.tail < 0 {
	d.tail = len(d.items) - 1
}
d.count--
if d.count == 0 {
	d.head = -1
	d.tail = -1
}
return item

}

func main() {
dequeue := NewDequeue()
// Insertar elementos en la frente y en la parte trasera de la dequeue.
dequeue.PushFront(1)
dequeue.PushBack(2)
dequeue.PushBack(3)
dequeue.PushFront(0)

// Imprimir elementos en la dequeue.
fmt.Println("Elementos en la dequeue:")
for i := 0; i < dequeue.count; i++ {
	fmt.Println(dequeue.PopFront())
}

🔥 Ejemplos de uso de dequeues (🔄) 🔥

Las dequeues (🔄) son útiles en una variedad de problemas de computación 💻. Aquí hay algunos de los usos más comunes:

1. Colas con prioridad (🅿️): Una dequeue (🔄) puede usarse para implementar una cola con prioridad, donde los elementos con mayor prioridad se procesan antes que los de menor prioridad.
2. Cache (🔐): Las dequeues (🔄) pueden ser utilizadas para implementar una cache de tamaño limitado. Cuando se alcanza el límite de tamaño, se eliminan los elementos más antiguos.
3. Procesamiento de ventanas deslizantes (🪟): En algoritmos que procesan ventanas deslizantes, como los algoritmos de detección de movimiento en vídeo 📹, una dequeue (🔄) se puede usar para mantener y manipular los elementos en la ventana.
4. Grafos y árboles (🌳): Las dequeues (🔄) pueden ser utilizadas en la búsqueda en anchura y profundidad en grafos y árboles.
5. Edición de texto (✍️): Una dequeue (🔄) se puede usar para implementar una lista de caracteres en un editor de texto, donde se pueden insertar y eliminar elementos en ambos extremos.

Estos son solo algunos ejemplos; la versatilidad de las dequeues (🔄) las hace aplicables a muchos otros problemas de computación 💻.

🎓 Conclusión

En resumen, una dequeue (🔄) es una estructura de datos útil y versátil que se puede utilizar en muchos problemas de computación. Esperamos que esta introducción te haya dado una idea de lo que son las dequeues (🔄) y cómo se pueden implementar en Go 🏁. Si tienes preguntas o comentarios adicionales, ¡no dudes en dejarlos a continuación! 💬

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

1. Implementa una función NewDeque() que crea una nueva deque vacía y devuelve un puntero a ella.

2. Implementa una función Size(d *Deque) int que devuelve el número de elementos en la deque d.

3. Implementa una función IsEmpty(d *Deque) bool que devuelve verdadero si la deque d está vacía, falso en caso contrario.

4. Implementa una función PushFront(d *Deque, value interface{}) que añade un elemento al frente de la deque d.

5. Implementa una función PushBack(d *Deque, value interface{}) que añade un elemento al final de la deque d.

6. Implementa una función PopFront(d *Deque) (interface{}, error) que elimina y devuelve el elemento del frente de la deque d. Si la deque está vacía, devuelve un error.

7. Implementa una función PopBack(d *Deque) (interface{}, error) que elimina y devuelve el elemento del final de la deque d. Si la deque está vacía, devuelve un error.

8. Implementa una función Front(d *Deque) (interface{}, error) que devuelve el elemento del frente de la deque d sin eliminarlo. Si la deque está vacía, devuelve un error.

9. Implementa una función Back(d *Deque) (interface{}, error) que devuelve el elemento del final de la deque d sin eliminarlo. Si la deque está vacía, devuelve un error.

10. Escribe un programa que utilice todas las funciones implementadas en los ejercicios anteriores para realizar diversas operaciones con deques, como añadir y eliminar elementos, comprobar si está vacía y obtener el tamaño.

💪 Ejercicios para practicar

A continuación, te dejo un par de ejercicios para que practiques la estructura Deque (🔄) en Go y envíes la solución como un Pull request a este repositorio: Go Para Principiantes 🎓.

1. Implementa una función NewDeque() que crea una nueva deque vacía y devuelve un puntero a ella.
2. Implementa una función Size(d *Deque) int que devuelve el número de elementos en la deque d.
3. Implementa una función IsEmpty(d *Deque) bool que devuelve verdadero si la deque d está vacía, falso en caso contrario.
4. Implementa una función PushFront(d *Deque, value interface{}) que añade un elemento al frente de la deque d.
5. Implementa una función PushBack(d *Deque, value interface{}) que añade un elemento al final de la deque d.
6. Implementa una función PopFront(d *Deque) (interface{}, error) que elimina y devuelve el elemento del frente de la deque d. Si la deque está vacía, devuelve un error.
7. Implementa una función PopBack(d *Deque) (interface{}, error) que elimina y devuelve