Cola en idioma Go

Una cola es una estructura lineal que sigue un orden particular en el que se realizan las operaciones. El orden es Primero en entrar, primero en salir (FIFO) . 

Ahora, si está familiarizado con otros lenguajes de programación como C++, Java y Python, existen bibliotecas de colas incorporadas que se pueden usar para la implementación de colas, pero ese no es el caso en el caso de Golang . Incluso si no está familiarizado con ellos, sepa que Golang no proporciona una estructura de cola incorporada .

¿Cómo implementar Queue en Go Language?

Hay muchas formas de implementar colas en Golang utilizando otras estructuras de datos como:

1. Usar rebanadas 
2. Uso de estructuras
3. Uso de lista de enlaces

1. Implemente la cola usando segmentos en el lenguaje Go:

Implementación de la cola usando un segmento simple en el que las operaciones de poner y sacar de la cola se realizan usando funciones. y Underflow (la cola está vacía) se verifica durante la operación de eliminación de la cola.

package main
  
import "fmt"
  
func enqueue(queue []int, element int) []int {
queue = append(queue, element) // Simply append to enqueue.
fmt.Println("Enqueued:", element)
return queue
}
  
func dequeue(queue []int) (int, []int) {
element := queue[0] // The first element is the one to be dequeued.
if len(queue) == 1 {
 var tmp = []int{}
 return element, tmp
  
}
  
return element, queue[1:] // Slice off the element once it is dequeued.
}
  
func main() {
var queue = make([]int, 0)
  
queue = enqueue(queue, 10)
  
fmt.Println("After pushing 10 ", queue)
queue = enqueue(queue, 20)
  
fmt.Println("After pushing 20 ", queue)
queue = enqueue(queue, 30)
  
fmt.Println("After pushing 30 ", queue)
  
ele, queue := dequeue(queue)
fmt.Println("Queue After removing", ele, " :", queue)
  
queue = enqueue(queue, 40)
fmt.Println("After pushing 40 ", queue)
}

Output:
Enqueued: 10
After pushing 10  [10]
Enqueued: 20
After pushing 20  [10 20]
Enqueued: 30
After pushing 30  [10 20 30]
Queue After removing 10  : [20 30]
Enqueued: 40
After pushing 40  [20 30 40]

Nota: En esto, el problema es que no podemos definir el tamaño o la capacidad de la cola. Sin embargo, se puede hacer definiendo la cola como make([]int, 0, 10) donde el tercer parámetro determina la capacidad pero el problema surge cuando la capacidad aumenta dinámicamente en una condición de desbordamiento.

2. Uso de estructuras:

Para superar el problema del anterior, utilice Estructuras en su lugar, que consisten en 

• Elementos, es decir, elementos de la cola
• Tamaño, es decir, capacidad de 

Use Punteros para cambiar directamente la cola sin devolverla cada vez y verifique las condiciones de desbordamiento y subdesbordamiento:

package main
  
import (
    "errors"
    "fmt"
)
  
type Queue struct {
    Elements []int
    Size     int
}
  
func (q *Queue) Enqueue(elem int) {
    if q.GetLength() == q.Size {
        fmt.Println("Overflow")
        return
    }
    q.Elements = append(q.Elements, elem)
}
  
func (q *Queue) Dequeue() int {
    if q.IsEmpty() {
        fmt.Println("UnderFlow")
        return 0
    }
    element := q.Elements[0]
    if q.GetLength() == 1 {
        q.Elements = nil
        return element
    }
    q.Elements = q.Elements[1:]
    return element // Slice off the element once it is dequeued.
}
  
func (q *Queue) GetLength() int {
    return len(q.Elements)
}
  
func (q *Queue) IsEmpty() bool {
    return len(q.Elements) == 0
}
  
func (q *Queue) Peek() (int, error) {
    if q.IsEmpty() {
        return 0, errors.New("empty queue")
    }
    return q.Elements[0], nil
}
  
func main() {
    queue := Queue{Size: 3}
    fmt.Println(queue.Elements)
    queue.Enqueue(1)
    fmt.Println(queue.Elements)
    queue.Enqueue(2)
    fmt.Println(queue.Elements)
    queue.Enqueue(3)
    fmt.Println(queue.Elements)
    queue.Enqueue(5)
    fmt.Println(queue.Elements)
    elem := queue.Dequeue()
    fmt.Println(elem)
    fmt.Println(queue.Elements)
    queue.Enqueue(9)
    fmt.Println(queue.Elements)
    elem = queue.Dequeue()
    fmt.Println(elem)
    fmt.Println(queue.Elements)
  
}

Output:
[]
[1]
[1 2]
[1 2 3]
Overflow
[1 2 3]
1
[2 3]
[2 3 9]
2
[3 9]

Nota: Solíamos comparar la longitud de los elementos con el tamaño (capacidad definida) de la estructura de la cola, que es más bueno de usar.

3. Usando Lista de enlaces:

package main
import "container/list"
import "fmt"
  
func main() {
    // new linked list
    queue := list.New()
  
    // Simply append to enqueue.
    queue.PushBack(10)
    queue.PushBack(20)
    queue.PushBack(30)
  
    // Dequeue
    front:=queue.Front()
    fmt.Println(front.Value)
    queue.Remove(front)
}

Output:
10

Nota: En esto también surge el problema de la capacidad y para superarlo, es necesario inicializar una variable diferente y comparar la longitud de LinkList antes de cada retroceso.