Enqueue Operation in DSA Go - Execution Trace

Concept Flow - Enqueue Operation

Create new node with value

↓

Is queue empty?

Yes→Set head and tail to new node

No↓

Set tail.next to new node

↓

Update tail to new node

↓

Done

This flow shows how a new element is added to the end of a queue: create node, check if empty, link at tail, update tail pointer.

Execution Sample

DSA Go

func Enqueue(value int) {
  newNode := &Node{value: value}
  if queue.tail == nil {
    queue.head = newNode
    queue.tail = newNode
  } else {
    queue.tail.next = newNode
    queue.tail = newNode
  }
}

This code adds a new value to the end of a queue implemented as a linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with value 10	None	None	null
2	Check if queue is empty (tail == nil)	None	None	null
3	Queue empty: set head and tail to new node	10	head -> 10, tail -> 10	10 -> null
4	Create new node with value 20	10	None	10 -> null
5	Check if queue is empty (tail != nil)	10	None	10 -> null
6	Set tail.next to new node (20)	10 -> 20	tail.next -> 20	10 -> 20 -> null
7	Update tail to new node (20)	10 -> 20	tail -> 20	10 -> 20 -> null
8	Create new node with value 30	10 -> 20	None	10 -> 20 -> null
9	Check if queue is empty (tail != nil)	10 -> 20	None	10 -> 20 -> null
10	Set tail.next to new node (30)	10 -> 20 -> 30	tail.next -> 30	10 -> 20 -> 30 -> null
11	Update tail to new node (30)	10 -> 20 -> 30	tail -> 30	10 -> 20 -> 30 -> null
12	End of enqueue operations	10 -> 20 -> 30	tail -> 30	10 -> 20 -> 30 -> null

💡 All enqueue operations completed; queue tail updated to last node.

Variable Tracker

Variable	Start	After Step 3	After Step 7	After Step 11	Final
head	nil	Node(10)	Node(10)	Node(10)	Node(10)
tail	nil	Node(10)	Node(20)	Node(30)	Node(30)
queue size	0	1	2	3	3

Key Moments - 3 Insights

Why do we check if the queue is empty before adding a new node?

Because if the queue is empty (tail is nil), both head and tail must point to the new node. This is shown in execution_table step 3 where head and tail are set to the new node.

Why do we update tail.next before moving tail to the new node?

Updating tail.next links the new node to the end of the queue. Then tail moves to the new node to keep track of the last element. See execution_table steps 6 and 7 for this sequence.

What happens if we forget to update the tail pointer after enqueue?

The tail pointer would still point to the old last node, so future enqueues would not link correctly. The queue would be broken. This is prevented by step 7 and 11 in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the queue after step 7?

A 20 -> 10 -> null with tail at 10

B 10 -> null with tail at 10

C 10 -> 20 -> null with tail at 20

D 10 -> 20 -> 30 -> null with tail at 30

💡 Hint

Check the Visual State and Pointer Changes columns at step 7 in execution_table.

At which step does the queue first have two nodes?

A Step 3

B Step 6

C Step 10

D Step 11

💡 Hint

Look at the Nodes in List column to see when the list grows from one to two nodes.

If the queue was not empty, which operation happens first when enqueuing a new node?

A Create new node

B Set head to new node

C Set tail.next to new node

D Update tail pointer

💡 Hint

Refer to the execution_table steps where a new node is created before linking it.

Concept Snapshot

Enqueue Operation in a Queue:
- Create a new node with the value.
- If queue is empty, set head and tail to new node.
- Else, link new node at tail.next.
- Update tail pointer to new node.
- Queue grows at the tail end only.

Full Transcript

The enqueue operation adds a new element to the end of a queue. First, a new node is created with the given value. If the queue is empty, both head and tail pointers are set to this new node. If not empty, the current tail's next pointer is set to the new node, and then the tail pointer is updated to the new node. This ensures the queue maintains correct order and pointers. The execution table shows step-by-step how nodes are added and pointers updated, with the visual state of the queue after each step. Key moments clarify why checking for empty queue and updating pointers in order is important. The variable tracker shows how head, tail, and size change as nodes are enqueued.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Removes an element from the front of the queue

B. Checks if the queue is empty

C. Adds an element to the end of the queue

D. Returns the size of the queue

Solution

1. Step 1: Understand the queue structure

   A queue works like a line where new elements join at the end.

2. Step 2: Define enqueue operation

   Enqueue means adding a new element to the back of the queue.

3. Final Answer:

   Adds an element to the end of the queue -> Option C

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue means add at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue
• Thinking enqueue removes elements
• Mixing enqueue with checking size

2. Which of the following is the correct syntax to enqueue an element 5 into a queue named q in Go?

easy

A. q.Enqueue(5)

B. q.enqueue(5)

C. enqueue(q, 5)

D. q.add(5)

Solution

1. Step 1: Identify method naming conventions in Go

   Methods in Go are usually capitalized if exported, so Enqueue is correct.

2. Step 2: Check method call on queue instance

   Calling q.Enqueue(5) means calling method Enqueue on queue q with argument 5.

3. Final Answer:

   q.Enqueue(5) -> Option A

4. Quick Check:

   Method call with capital Enqueue = q.Enqueue(5) [OK]

Hint: Use capitalized method names for exported functions in Go [OK]

Common Mistakes:

• Using lowercase method names incorrectly
• Calling enqueue as a standalone function
• Using wrong method name like add

3. What will be the output of the following Go code snippet?

package main

import "fmt"

type Queue struct {
    items []int
}

func (q *Queue) Enqueue(val int) {
    q.items = append(q.items, val)
}

func (q *Queue) Print() {
    for _, v := range q.items {
        fmt.Print(v, " -> ")
    }
    fmt.Println("null")
}

func main() {
    q := Queue{}
    q.Enqueue(10)
    q.Enqueue(20)
    q.Enqueue(30)
    q.Print()
}

medium

A. Compilation error

B. 10 -> 20 -> 30 -> null

C. null

D. 30 -> 20 -> 10 -> null

Solution

1. Step 1: Understand enqueue implementation

   Enqueue appends new values at the end of the slice, so order is preserved as inserted.

2. Step 2: Trace the Print method output

   Print prints all items in order separated by ' -> ' and ends with 'null'.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option B

4. Quick Check:

   Enqueue appends, so output is 10 -> 20 -> 30 -> null [OK]

Hint: Enqueue appends at end, print shows order inserted [OK]

Common Mistakes:

• Thinking enqueue adds at front
• Confusing print order
• Assuming code has errors

4. Identify the error in the following Go code for enqueue operation:

package main

import "fmt"

type Queue struct {
    items []int
}

func (q Queue) Enqueue(val int) {
    q.items = append(q.items, val)
}

func main() {
    q := Queue{}
    q.Enqueue(5)
    fmt.Println(q.items)
}

medium

A. Enqueue method should have pointer receiver to modify queue

B. items slice should be initialized with make

C. fmt.Println is not imported

D. Append cannot be used on slices

Solution

1. Step 1: Check method receiver type

   The Enqueue method uses a value receiver, so changes to q.items do not affect original queue.

2. Step 2: Understand pointer receiver necessity

   To modify the original queue, Enqueue must have pointer receiver (q *Queue).

3. Final Answer:

   Enqueue method should have pointer receiver to modify queue -> Option A

4. Quick Check:

   Pointer receiver needed to modify struct [OK]

Hint: Use pointer receiver to modify struct fields [OK]

Common Mistakes:

• Using value receiver and expecting changes
• Forgetting to import fmt (not main error here)
• Thinking append can't be used on slices

5. You want to implement a queue using a linked list in Go. Which step is essential in the Enqueue operation to maintain the queue correctly?

hard

A. Add new node at the head and do not update head pointer

B. Add new node at the head and update tail pointer

C. Add new node at the tail but do not update tail pointer

D. Add new node at the tail and update tail pointer

Solution

1. Step 1: Understand linked list queue structure

   Queue adds new elements at the tail (end) and removes from head (front).

2. Step 2: Enqueue operation details

   To enqueue, add new node at tail and update tail pointer to new node to keep track.

3. Final Answer:

   Add new node at the tail and update tail pointer -> Option D

4. Quick Check:

   Enqueue adds at tail and updates tail pointer [OK]

Hint: Enqueue adds at tail and updates tail pointer [OK]

Common Mistakes:

• Adding at head instead of tail
• Not updating tail pointer after enqueue
• Confusing head and tail roles