# How to Create a Queue in Go

A queue is a very useful data structure where one can store, add, and remove objects with the “First in, First out” (FIFO) principle. Queues are very useful for basic algorithms (such as bread-first search), so it is therefore worth learning how to implement them in Go. The best way to implement a queue using Go is by creating a `struct`. You can read more about `structs` in Go in [this blog post](https://alissalozhkin.hashnode.dev/structs-in-go).

The first step is to create the `struct` and call it `Queue`.

```go
type Queue struct {
	elements []int  // stores the objects in the queue
	size     int  // the maximum size of the queue
}
```

After defining the struct, we can define its methods, namely `GetLength()`, `Enqueue()`, and `Dequeue()`. By writing `(q *Queue)` when defining the function (where `q` denotes a `Queue` object), we specify that the method belongs to the `struct`.

```go
func (q *Queue) GetLength() int {
	return len(q.elements) // return current length of the queue
}

func (q *Queue) Enqueue(element int) {
	if q.GetLength() == q.size { // if the queue is at max length, don't add new element
		fmt.Println("Queue is full")
		return
	} else {
		q.elements = append(q.elements, element)
		return
	}
}

func (q *Queue) Dequeue() int {
	if q.GetLength() == 0 { // if queue is empty, there is nothing to dequeue
		fmt.Println("Queue is empty")
		return 0
	} else if q.GetLength() == 1 {
		temp := q.elements[0]
		q.elements = q.elements[:0] // if current length is 1, queue becomes empty
		return temp
	} else {
		temp := q.elements[0]
		q.elements = q.elements[1:]
		return temp // return the dequeued element
	}
}
```

The last step is to define the main function that will create and modify a `queue` object:

```go
import "fmt"

func main() {
	q := Queue{size: 3} // creates a queue with a max size of 3
	q.Enqueue(1)
	q.Enqueue(2)
	q.Enqueue(3)
	q.Enqueue(4)  // Queue is full
	fmt.Print(q.elements) // [1, 2, 3]
	elem1 := q.Dequeue()
	elem2 := q.Dequeue()
	elem3 := q.Dequeue()
	fmt.Println(elem1, elem2, elem3) // 1, 2, 3
	q.Dequeue() // Queue is empty
}
```

The `queue` data structure is now implemented!

Note that the `stack` data structure is very similar in implementation. Only the `Dequeue()` method needs to be changed to remove the last element in `elements` instead of the first.