Queue Implementation Using Array in DSA Go - Execution Trace

Concept Flow - Queue Implementation Using Array

Initialize empty array queue

↓

Enqueue: Add element at rear index

↓

Update rear pointer

↓

Dequeue: Remove element at front index

↓

Update front pointer

↓

Check if queue is empty or full

↓

Repeat operations or stop

This flow shows how elements are added at the rear and removed from the front in an array-based queue, updating pointers accordingly.

Execution Sample

DSA Go

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

This code enqueues two elements (10, 20) and then dequeues one element from the front.

Execution Table

Step	Operation	Front Pointer	Rear Pointer	Queue Array State	Visual State
1	Initialize queue	0	0	[]	Front=0, Rear=0, Queue=[]
2	Enqueue 10	0	1	[10]	Front=0, Rear=1, Queue=[10]
3	Enqueue 20	0	2	[10, 20]	Front=0, Rear=2, Queue=[10, 20]
4	Dequeue (remove 10)	1	2	[10, 20]	Front=1, Rear=2, Queue=[10, 20] (10 is dequeued)
5	Check if empty	1	2	[10, 20]	Queue not empty since Front < Rear
6	Check if full (not implemented)	1	2	[10, 20]	Queue not full (array can grow)

💡 Execution stops after one dequeue and checks; queue has elements [20] logically from front=1 to rear=2

Variable Tracker

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

Key Moments - 3 Insights

Why does the queue array still show [10, 20] after dequeueing 10?

Because dequeue only moves the front pointer forward (see Step 4 in execution_table), it does not remove the element physically from the array. The logical queue is from front to rear.

What happens if we enqueue more elements than the array size?

In this implementation, the array grows dynamically with append (see Steps 2 and 3). So the queue can expand as needed.

Why do we check if front == rear to know if the queue is empty?

Because front points to the first valid element and rear points to the position after the last element. If front equals rear, no elements remain (see Step 5).

Visual Quiz - 3 Questions

Look at the execution_table at Step 4, what is the value of the front pointer?

A 0

B 2

C 1

D 3

💡 Hint

Check the 'Front Pointer' column at Step 4 in the execution_table.

At which step does the queue first contain two elements?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Queue Array State' column to see when two elements appear.

If we dequeue again after Step 4, what will be the front pointer value?

A 2

B 1

C 3

D 0

💡 Hint

Each dequeue increments the front pointer by 1 as shown in variable_tracker.

Concept Snapshot

Queue using array:
- Enqueue adds element at rear index
- Dequeue removes element from front index
- front and rear pointers track positions
- Queue empty if front == rear
- Array can grow dynamically with append

Full Transcript

This visual trace shows how a queue is implemented using an array. We start with empty queue and pointers front=0 and rear=0. Enqueue adds elements at rear and increments rear. Dequeue moves front forward without removing elements physically. The queue is empty when front equals rear. The array grows dynamically as elements are added. The execution table tracks each step's pointers and queue state, helping understand the logical queue inside the array.

Practice

1. What is the main characteristic of a queue implemented using an array?

easy

A. It allows random access to elements

B. It follows Last-In-First-Out (LIFO) order

C. It follows First-In-First-Out (FIFO) order

D. It stores elements in sorted order

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the rear and removes from the front, so the first element added is the first removed.

2. Step 2: Match behavior with options

   This behavior is called First-In-First-Out (FIFO), which matches It follows First-In-First-Out (FIFO) order.

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option C

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue means first in, first out order [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements automatically

2. Which of the following is the correct way to declare a fixed-size queue array of size 5 in Go?

easy

A. var queue [5]int

B. queue := []int{5}

C. queue := [5]int

D. queue := make([]int, 5)

Solution

1. Step 1: Understand array declaration in Go

   Fixed-size arrays in Go are declared with var name [size]type, e.g., var queue [5]int.

2. Step 2: Check options for fixed-size array

   var queue [5]int uses var queue [5]int which is correct fixed-size array syntax.

3. Final Answer:

   var queue [5]int -> Option A

4. Quick Check:

   Fixed array = var name [size]type [OK]

Hint: Fixed array uses var name [size]type in Go [OK]

Common Mistakes:

• Using make for fixed-size array (make is for slices)
• Using slice literal with size inside braces
• Confusing slice and array syntax

3. Consider this Go code snippet implementing a queue using an array and two indices front and rear:

var queue [5]int
front, rear := -1, -1

// Enqueue 10
rear++
queue[rear] = 10

// Enqueue 20
rear++
queue[rear] = 20

// Dequeue
front++

// Enqueue 30
rear++
queue[rear] = 30

// Current queue elements from front+1 to rear are printed

What will be the printed queue elements?

medium

A. [20, 30]

B. [10, 20, 30]

C. [10, 30]

D. [30]

Solution

1. Step 1: Trace enqueue and dequeue operations

   Initially front = -1, rear = -1. Enqueue 10: rear=0, queue[0]=10 Enqueue 20: rear=1, queue[1]=20 Dequeue: front=0 (removes queue[0]=10) Enqueue 30: rear=2, queue[2]=30

2. Step 2: Identify current queue elements

   Queue elements are from front+1=1 to rear=2, so queue[1]=20 and queue[2]=30. Printed elements: [20, 30]

3. Final Answer:

   [20, 30] -> Option A

4. Quick Check:

   After dequeue, front=0; elements = queue[1..2] = [20,30] [OK]

Hint: Queue elements lie between front+1 and rear indices [OK]

Common Mistakes:

• Printing elements from 0 to rear ignoring front
• Not updating front after dequeue
• Confusing front and rear indices

4. Given this Go code snippet for dequeue operation in a queue implemented with array:

func dequeue() int {
    if front == rear {
        fmt.Println("Queue is empty")
        return -1
    }
    front++
    return queue[front]
}

What is the main bug in this code?

medium

A. It does not check if queue is full before dequeue

B. It should decrement rear instead of front

C. It increments front before returning element, causing off-by-one error

D. It returns queue[front] after increment, which is correct

Solution

1. Step 1: Understand dequeue logic

   Dequeue removes element at front+1 index. Incrementing front before returning queue[front] is correct to get the next element.

2. Step 2: Analyze options for bug

   It does not check if queue is full before dequeue is unrelated to dequeue. It increments front before returning element, causing off-by-one error says increment causes off-by-one error but this is standard for queue. It should decrement rear instead of front is wrong because rear is for enqueue. It returns queue[front] after increment, which is correct correctly states the code is correct.

3. Final Answer:

   It returns queue[front] after increment, which is correct -> Option D

4. Quick Check:

   Increment front then return element = correct dequeue [OK]

Hint: Dequeue increments front then returns element [OK]

Common Mistakes:

• Thinking front should not be incremented before return
• Confusing enqueue and dequeue pointers
• Checking full condition in dequeue

5. You have a fixed-size queue implemented using an array of size 5 with front and rear indices initialized to -1. After performing these operations:

Enqueue 5
Enqueue 10
Enqueue 15
Dequeue
Dequeue
Enqueue 20
Enqueue 25
Enqueue 30
Enqueue 35

What will happen when you try to enqueue 35, and what is the correct way to handle this situation?

hard

A. Queue underflow occurs; reset front and rear to -1

B. Queue overflow occurs; use circular queue logic to reuse space

C. Queue accepts 35 without issue; no special handling needed

D. Queue overflow occurs; increase array size dynamically

Solution

1. Step 1: Trace queue operations and indices

   Initial front = -1, rear = -1 Enqueue 5: rear=0 Enqueue 10: rear=1 Enqueue 15: rear=2 Dequeue: front=0 (removes 5) Dequeue: front=1 (removes 10) Enqueue 20: rear=3 Enqueue 25: rear=4 Enqueue 30: rear=5 (array size 5, index 5 invalid - overflow) Trying to enqueue 35 causes overflow

2. Step 2: Explain correct handling

   Since front has moved forward, space at start is free but rear reached end. Using circular queue logic allows rear to wrap to start and reuse space. Without circular logic, overflow occurs prematurely.

3. Final Answer:

   Queue overflow occurs; use circular queue logic to reuse space -> Option B

4. Quick Check:

   Overflow at end; circular queue fixes space reuse [OK]

Hint: Use circular queue to avoid overflow when space is free [OK]

Common Mistakes:

• Ignoring free space at start after dequeues
• Assuming array can grow dynamically
• Resetting front and rear incorrectly