Queue Implementation Using Array in DSA Python - Execution Trace

Concept Flow - Queue Implementation Using Array

Initialize empty array queue

↓

Enqueue: Add element at end

↓

Check if queue is full?

Yes→Reject enqueue

No↓

Dequeue: Remove element from front

↓

Check if queue is empty?

Yes→Reject dequeue

No↓

Shift front pointer forward

↓

Repeat operations as needed

This flow shows how elements are added at the end and removed from the front of an array-based queue, with checks for full and empty states.

Execution Sample

DSA Python

queue = []
front = 0
rear = -1

# Enqueue 10
rear += 1
queue.append(10)

# Enqueue 20
rear += 1
queue.append(20)

# Dequeue
if front <= rear:
    item = queue[front]
    front += 1

This code enqueues two elements and dequeues one by moving the front pointer.

Execution Table

Step	Operation	Queue Array	Front Pointer	Rear Pointer	Visual State
1	Initialize queue	[]	0	-1	Queue: [] Front=0 Rear=-1
2	Enqueue 10	[10]	0	0	Queue: [10] Front=0 Rear=0
3	Enqueue 20	[10, 20]	0	1	Queue: [10, 20] Front=0 Rear=1
4	Dequeue (remove 10)	[10, 20]	1	1	Queue: [10, 20] Front=1 Rear=1 (10 removed)
5	Enqueue 30	[10, 20, 30]	1	2	Queue: [10, 20, 30] Front=1 Rear=2
6	Dequeue (remove 20)	[10, 20, 30]	2	2	Queue: [10, 20, 30] Front=2 Rear=2 (20 removed)
7	Dequeue (remove 30)	[10, 20, 30]	3	2	Queue: [10, 20, 30] Front=3 Rear=2 (30 removed)
8	Dequeue attempt on empty queue	[10, 20, 30]	3	2	Queue empty: Front > Rear, cannot dequeue

💡 Step 8 stops because front pointer (3) is greater than rear pointer (2), meaning queue is empty.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8
queue	[]	[10]	[10, 20]	[10, 20]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
front	0	0	0	1	1	2	3	3
rear	-1	0	1	1	2	2	2	2

Key Moments - 3 Insights

Why does the front pointer move forward instead of removing the element physically?

Because in array-based queue, we just move the front pointer to mark the next element as front. The old element stays but is ignored. See Step 4 and Step 6 in execution_table where front moves but array stays same.

What happens when front pointer becomes greater than rear pointer?

It means the queue is empty and no elements can be dequeued. This is shown in Step 8 where dequeue is rejected because front=3 > rear=2.

Why does rear pointer start at -1?

Rear starts at -1 to indicate the queue is empty initially. When first element is enqueued, rear moves to 0. See Step 1 and Step 2 in execution_table.

Visual Quiz - 3 Questions

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

A 0

B 1

C 2

D 3

💡 Hint

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

At which step does the queue become empty?

A Step 6

B Step 8

C Step 7

D Step 4

💡 Hint

Look for when front pointer is greater than rear pointer in execution_table.

If we enqueue 40 after Step 7, what will be the rear pointer value?

A 3

B 2

C 4

D 5

💡 Hint

Rear pointer increments by 1 on enqueue; see rear pointer changes in variable_tracker.

Concept Snapshot

Queue using array:
- Enqueue adds element at rear (end)
- Dequeue removes element from front
- Use front and rear pointers
- Queue empty if front > rear
- Rear starts at -1, front at 0

Full Transcript

This visualization shows how a queue works using an array. We add elements at the rear end and remove from the front. The front and rear pointers track where to remove and add. Initially, the queue is empty with rear at -1 and front at 0. When we enqueue, rear moves forward and element is added. When we dequeue, front moves forward to ignore the removed element. The array keeps all elements but only those between front and rear are valid. When front pointer passes rear pointer, the queue is empty and no dequeue is possible. This simple pointer movement avoids shifting elements in the array.

Practice

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

easy

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

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

C. It allows random access to elements

D. It automatically sorts elements

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the rear and removes from the front, following FIFO.

2. Step 2: Compare options

   LIFO is for stacks, random access and sorting are not queue properties.

3. Final Answer:

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

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue always removes the oldest element first [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 initialize an empty queue using an array in Python?

easy

A. queue = ()

B. queue = {}

C. queue = set()

D. queue = []

Solution

1. Step 1: Identify array type in Python

   Python lists are used as arrays and initialized with [] for empty list.

2. Step 2: Check other options

   {} is dict, () is tuple, set() is a set, none are arrays.

3. Final Answer:

   queue = [] -> Option D

4. Quick Check:

   Empty array = [] [OK]

Hint: Use [] to create empty list (array) in Python [OK]

Common Mistakes:

• Using {} which creates a dictionary
• Using () which creates a tuple
• Using set() which is unordered

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

queue = []
queue.append(10)
queue.append(20)
queue.append(30)
print(queue.pop(0))
print(queue)

medium

A. 30
[10, 20]

B. 10
[20, 30]

C. 10
[10, 20, 30]

D. 20
[10, 30]

Solution

1. Step 1: Trace queue operations

   Append adds 10, 20, 30 to queue: [10, 20, 30]. pop(0) removes first element 10.

2. Step 2: Check print outputs

   First print outputs 10, second print outputs remaining queue [20, 30].

3. Final Answer:

   10 [20, 30] -> Option B

4. Quick Check:

   pop(0) removes front = 10 [OK]

Hint: pop(0) removes front element in queue [OK]

Common Mistakes:

• Using pop() instead of pop(0) removes last element
• Confusing append order
• Expecting pop(0) to remove last element

4. Identify the error in this queue implementation using an array:

queue = []
queue.append(1)
queue.append(2)
queue.pop()
print(queue)

medium

A. pop() removes last element, not front

B. append() is used incorrectly

C. queue should be a dictionary

D. print statement syntax error

Solution

1. Step 1: Understand pop() behavior

   pop() without index removes last element, not front as queue requires.

2. Step 2: Check queue correctness

   Queue must remove front element, so pop(0) should be used instead of pop().

3. Final Answer:

   pop() removes last element, not front -> Option A

4. Quick Check:

   Queue removal = pop(0) front [OK]

Hint: Use pop(0) to dequeue from front [OK]

Common Mistakes:

• Using pop() removes last, not front
• Confusing append usage
• Thinking queue is a dictionary

5. Given a fixed-size array of length 3, what happens if you try to enqueue 4 elements in a queue implemented using this array without resizing or circular logic?

hard

A. The queue automatically resizes to fit 4 elements

B. The 4th element replaces the first element

C. The queue overflows and cannot add the 4th element

D. The queue removes the last element to add the 4th

Solution

1. Step 1: Understand fixed-size array limits

   An array of length 3 can hold only 3 elements; no extra space for 4th.

2. Step 2: Check enqueue behavior without resizing

   Without resizing or circular logic, adding 4th element causes overflow error or failure.

3. Final Answer:

   The queue overflows and cannot add the 4th element -> Option C

4. Quick Check:

   Fixed array size = no extra elements [OK]

Hint: Fixed array size limits enqueue capacity [OK]

Common Mistakes:

• Assuming automatic resizing happens
• Thinking 4th element replaces first
• Believing queue removes last element automatically