Queue in Go Language

Last Updated : 29 Jul, 2022

A queue is a linear structure that follows a particular order in which the operations are performed. The order is First In First Out (FIFO).

Now if you are familiar with other programming languages like C++, Java, and Python then there are inbuilt queue libraries that can be used for the implementation of queues, but such is not the case in the case of Golang. Even if you are not familiar with those then just know that Golang does not provide an inbuilt queue structure.

How to implement Queue in Go Language?

There are many ways to implement queues in Golang using other Data structures as:

Using Slices
Using Structures
Using LinkList

1. Implement Queue Using Slices in Go Language:

Implementing queue using a simple slice in which enqueueing and dequeuing operations are done using functions. and Underflow(queue is empty) is checked during dequeuing operation.

Go

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]

Note: In this, the problem is we can not define the size or capacity of the queue. However, it can be done by defining the queue as make([]int, 0, 10) where the third parameter determines capacity but the problem arises when capacity dynamically increases in an overflow condition.

2. Using Structures:

To overcome the problem in the earlier one, use Structures instead which consist of

Elements i.e. queue Elements
Size i.e. Capacity of

Use Pointers to directly change the queue without returning it every time and, check for both overflow and underflow conditions:

Go

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]

Note: We used to compare the length of elements to the size(Capacity defined) of queue structure which is more good to use.

3. Using LinkList:

Go

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

Note: In this also the capacity problem arises and to overcome that, there is a need to initialize a different variable and compare the length of the LinkList before every pushback.