Saltar al contenido

Cola en idioma Go – GeeksforGeeks

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 bien, si está familiarizado con otros lenguajes de programación como C++, Java y Python, existen bibliotecas de colas integradas que se pueden usar para la implementación de colas, pero ese no es el caso con Golang. Incluso si no lo sabes, solo sé Golang no ofrece una estructura de cola integrada.

¿Cómo implementar Queue en Go Language?

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

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

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

Implemente la puesta en cola mediante un segmento simple en el que la puesta en cola y la puesta en cola se realizan mediante funciones. y Subdesbordamiento (la cola está vacía) se verifica mientras se cancela la cola.

Que debe llevar

package main

 

import "fmt"

 

func enqueue(queue []int, element int) []int {

queue = append(queue, element)

fmt.Println("Enqueued:", element)

return queue

}

 

func dequeue(queue []int) (int, []int) {

elemento := cola[0]

if len(queue) == 1 {

 var tmp = []int{}

 return element, tmp

 

}

 

return elemento, cola[1:]

}

 

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]

Observación: El problema aquí 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 resolver el problema del anterior, utilice en su lugar Estructuras que consisten en:

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

Use Punteros para cambiar instantáneamente la cola sin enviarla de vuelta cada vez y verifique las condiciones de desbordamiento y subdesbordamiento:

Para llevar

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

    }

    elemento := q.Elementos[0]

    if q.GetLength() == 1 {

        q.Elements = nil

        return element

    }

    q.Elementos = q.Elementos[1:]

    return element

}

 

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.Elementos[0]cero

}

 

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]

Observación: Solíamos comparar la longitud de los elementos con el tamaño (capacidad definida) de la estructura de la cola que es más útil.

3. Usando Lista de enlaces:

Para llevar

package main

import "container/list"

import "fmt"

 

func main() {

    

    queue := list.New()

 

    

    queue.PushBack(10)

    queue.PushBack(20)

    queue.PushBack(30)

 

    

    front:=queue.Front()

    fmt.Println(front.Value)

    queue.Remove(front)

}

Output:
10

Observación: En esto también surge el problema de la capacidad y para solucionarlo es necesario inicializar otra variable y comparar la longitud de la LinkList para cada pushback.