Queue Concept and FIFO Principle in DSA Go - Execution Trace

Concept Flow - Queue Concept and FIFO Principle

Start

↓

Enqueue: Add item at rear

↓

Queue grows: Rear moves forward

↓

Dequeue: Remove item from front

↓

Queue shrinks: Front moves forward

↓

Repeat Enqueue/Dequeue

↓

Empty when front == rear

↓

End

Items enter the queue at the rear and leave from the front, following First In First Out order.

Execution Sample

DSA Go

queue := []int{}
queue = append(queue, 10) // Enqueue 10
queue = append(queue, 20) // Enqueue 20
front := queue[0]          // Dequeue 10
queue = queue[1:]          // Remove front

This code adds two items to the queue and then removes the first item, showing FIFO behavior.

Execution Table

Step	Operation	Nodes in Queue	Pointer Changes	Visual State
1	Start with empty queue	[]	front: nil, rear: nil	null
2	Enqueue 10	[10]	front: 0, rear: 0	10 -> null
3	Enqueue 20	[10, 20]	front: 0, rear: 1	10 -> 20 -> null
4	Dequeue (remove 10)	[20]	front: 1, rear: 1	20 -> null
5	Queue state after dequeue	[20]	front: 1, rear: 1	20 -> null
6	Dequeue (remove 20)	[]	front: 2, rear: 1	null
7	Queue empty check	[]	front: 2, rear: 1	null

💡 Queue is empty when front pointer passes rear pointer or no elements remain.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 6	Final
queue	[]	[10]	[10, 20]	[20]	[]	[]
front	nil	0	0	1	2	2
rear	nil	0	1	1	1	1

Key Moments - 3 Insights

Why does the front pointer move forward after dequeue?

Because dequeue removes the front item, the front pointer moves to the next item to keep track of the current front, as shown in steps 4 and 6 in the execution_table.

What happens when the queue becomes empty?

When front pointer passes rear pointer or no elements remain in the queue slice, the queue is empty, as seen in step 6 and 7 where queue is [].

Why do we add items at the rear and remove from the front?

This maintains the FIFO order: first item added is the first removed. Enqueue adds at rear (steps 2 and 3), dequeue removes from front (steps 4 and 6).

Visual Quiz - 3 Questions

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

A [20]

B [10, 20]

C []

D [10]

💡 Hint

Check the 'Nodes in Queue' column at step 3 in execution_table.

At which step does the front pointer move from 0 to 1?

A Step 2

B Step 3

C Step 4

D Step 6

💡 Hint

Look at the 'Pointer Changes' column in execution_table for front pointer values.

If we enqueue 30 after step 6, what will be the new rear pointer value?

A 2

B 1

C 3

D 0

💡 Hint

After step 6, rear is 1; enqueue adds one item at rear +1.

Concept Snapshot

Queue stores items in order.
Enqueue adds at rear.
Dequeue removes from front.
Follows FIFO: first in, first out.
Empty when no items remain.
Pointers track front and rear positions.

Full Transcript

A queue is a data structure where items enter at the rear and leave from the front, following the First In First Out principle. We start with an empty queue. When we enqueue, we add items at the rear, moving the rear pointer forward. When we dequeue, we remove the item at the front, moving the front pointer forward. The queue is empty when the front pointer passes the rear pointer or no items remain. This behavior ensures the first item added is the first removed, maintaining order.

Practice

1. What does the FIFO principle mean in the context of a queue?

easy

A. First In, First Out - the last element added is the first removed

B. First In, First Out - the first element added is the first removed

C. Last In, First Out - the first element added is the last removed

D. Last In, First Out - the last element added is the last removed

Solution

1. Step 1: Understand FIFO meaning

   FIFO means the first element that enters the queue is the first to leave.

2. Step 2: Match FIFO to queue behavior

   Queues follow FIFO, so the first added element is removed first.

3. Final Answer:

   First In, First Out - the first element added is the first removed -> Option B

4. Quick Check:

   FIFO = First In, First Out [OK]

Hint: Remember queue = line; first come, first served [OK]

Common Mistakes:

• Confusing FIFO with LIFO
• Thinking last added is removed first
• Mixing stack behavior with queue

2. Which of the following is the correct way to declare a queue using a slice in Go?

easy

A. queue := []int{}

B. var queue []int

C. queue := make(map[int]int)

D. var queue int

Solution

1. Step 1: Identify slice declaration for queue

   In Go, a queue can be represented as a slice, initialized as empty with []int{}.

2. Step 2: Check options for correct slice syntax

   queue := []int{} uses slice literal syntax to create an empty int slice, suitable for queue.

3. Final Answer:

   queue := []int{} -> Option A

4. Quick Check:

   Slice queue declaration = queue := []int{} [OK]

Hint: Use slice literal []int{} for empty queue [OK]

Common Mistakes:

• Using map instead of slice
• Declaring queue as single int variable
• Using var without initialization for slice

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

package main
import "fmt"
func main() {
  queue := []int{10, 20, 30}
  // Dequeue operation
  first := queue[0]
  queue = queue[1:]
  fmt.Println(first)
  fmt.Println(queue)
}

medium

A. 10
[10 20 30]

B. 20
[10 30]

C. 10
[20 30]

D. 30
[10 20]

Solution

1. Step 1: Identify dequeue operation

   The first element 10 is stored in 'first', then queue is sliced from index 1 onward.

2. Step 2: Determine output values

   Printing 'first' outputs 10; printing 'queue' outputs remaining slice [20 30].

3. Final Answer:

   10 [20 30] -> Option C

4. Quick Check:

   Dequeue removes first element = 10, queue left = [20 30] [OK]

Hint: Dequeue removes first element, slice queue from index 1 [OK]

Common Mistakes:

• Printing old queue without slicing
• Confusing index positions
• Assuming queue unchanged after dequeue

4. Identify the error in the following Go code that tries to enqueue an element to a queue represented by a slice:

package main
func main() {
  queue := []int{1, 2, 3}
  queue[3] = 4
}

medium

A. Compile error because queue is not declared

B. Syntax error due to missing import statement

C. No error; element 4 is added correctly

D. Index out of range error because slice index 3 does not exist

Solution

1. Step 1: Analyze slice indexing

   Slice 'queue' has length 3 with indices 0,1,2; index 3 is out of range.

2. Step 2: Understand how to add elements

   To add elements, use append(queue, 4) instead of direct index assignment.

3. Final Answer:

   Index out of range error because slice index 3 does not exist -> Option D

4. Quick Check:

   Accessing queue[3] invalid for length 3 slice [OK]

Hint: Use append to add elements, not direct index assignment [OK]

Common Mistakes:

• Trying to assign beyond slice length
• Forgetting to use append for enqueue
• Assuming slice auto-expands on index assignment

5. Given a queue implemented as a slice in Go, how would you write a function to enqueue multiple elements at once while preserving FIFO order? Choose the correct code snippet.

func enqueueMultiple(queue []int, elements []int) []int {
  // Fill in
}

hard

A. return append(queue, elements...)

B. return append(elements, queue...)

C. for _, e := range elements { queue = append([]int{e}, queue...) } return queue

D. queue = elements; return queue

Solution

1. Step 1: Understand enqueue multiple elements

   To add multiple elements preserving order, append all new elements at the end of queue.

2. Step 2: Check code options for correct append usage

   return append(queue, elements...) uses append(queue, elements...) which adds all elements at the end in order.

3. Final Answer:

   return append(queue, elements...) -> Option A

4. Quick Check:

   Appending elements at end preserves FIFO enqueue order [OK]

Hint: Use append(queue, elements...) to add multiple items [OK]

Common Mistakes:

• Appending new elements before queue (wrong order)
• Replacing queue instead of appending
• Appending elements one by one at front