Circular Queue Implementation Using Array in DSA C - Execution Trace

Concept Flow - Circular Queue Implementation Using Array

Initialize front = -1, rear = -1

↓

Enqueue Operation

↓

Check if queue is full?

↓

Reject enqueue

↓

If empty, set front=0

↓

Insert element at rear

↓

Update rear = (rear + 1) % size

↓

Dequeue Operation

↓

Check if queue is empty?

↓

Reject dequeue

↓

Remove element at front

↓

If front == rear, reset front and rear to -1

↓

Repeat operations as needed

This flow shows how a circular queue uses front and rear pointers to enqueue and dequeue elements in a fixed-size array, wrapping around when reaching the end.

Execution Sample

DSA C

int size = 5;
int queue[5];
int front = -1, rear = -1;
// Enqueue 10, 20, 30
// Dequeue one element
// Enqueue 40, 50, 60

This code enqueues three elements, dequeues one, then enqueues three more to show circular behavior.

Execution Table

Step	Operation	front	rear	Queue Array	Pointer Changes	Visual State
1	Initialize queue	-1	-1	[_, _, _, _, _]	front = -1, rear = -1	Empty queue
2	Enqueue 10	0	0	[10, _, _, _, _]	front=0 (was -1), rear=0	10 inserted at index 0
3	Enqueue 20	0	1	[10, 20, _, _, _]	rear=1	20 inserted at index 1
4	Enqueue 30	0	2	[10, 20, 30, _, _]	rear=2	30 inserted at index 2
5	Dequeue	1	2	[10, 20, 30, _, _]	front=1	10 removed from index 0
6	Enqueue 40	1	3	[10, 20, 30, 40, _]	rear=3	40 inserted at index 3
7	Enqueue 50	1	4	[10, 20, 30, 40, 50]	rear=4	50 inserted at index 4
8	Enqueue 60 (wrap)	1	0	[60, 20, 30, 40, 50]	rear=0 (wrap)	60 inserted at index 0 (wrap)
9	Queue Full Check	1	0	[60, 20, 30, 40, 50]	front=1, rear=0	Queue is full, next enqueue rejected
10	Dequeue	2	0	[60, 20, 30, 40, 50]	front=2	20 removed from index 1
11	Dequeue	3	0	[60, 20, 30, 40, 50]	front=3	30 removed from index 2
12	Dequeue	4	0	[60, 20, 30, 40, 50]	front=4	40 removed from index 3
13	Dequeue	0	0	[60, 20, 30, 40, 50]	front=0	50 removed from index 4
14	Dequeue last element	-1	-1	[60, 20, 30, 40, 50]	front=-1, rear=-1	60 removed from index 0, queue empty
15	Queue Empty Check	-1	-1	[60, 20, 30, 40, 50]	front=-1, rear=-1	Queue is empty, dequeue rejected

💡 Execution stops as queue is full at step 9 and empty at step 15, no further enqueue or dequeue possible.

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	After Step 9	After Step 10	After Step 11	After Step 12	After Step 13	After Step 14	After Step 15
front	-1	0	0	0	1	1	1	1	1	2	3	4	0	-1	-1
rear	-1	0	1	2	2	3	4	0	0	0	0	0	0	-1	-1

Key Moments - 3 Insights

Why does rear wrap to 0 after reaching the end of the array?

Because the queue is circular, rear uses modulo operation (rear + 1) % size to wrap around. See step 8 in execution_table where rear moves from 4 to 0.

Why do we reset front and rear to -1 after removing the last element?

When front equals rear and we dequeue, the queue becomes empty. Resetting front and rear to -1 marks the empty state. See step 14 in execution_table.

How do we know the queue is full?

Queue is full when the next rear position equals front. At step 9, rear=0 and front=1, so next enqueue is rejected because (rear + 1) % size == front.

Visual Quiz - 3 Questions

Look at the execution_table at step 8, what is the position of rear after enqueueing 60?

A 4

B 0

C 1

D 3

💡 Hint

Check the 'rear' column at step 8 in execution_table.

At which step does the queue become empty again after multiple dequeues?

A Step 14

B Step 13

C Step 12

D Step 15

💡 Hint

Look at front and rear values resetting to -1 in variable_tracker and execution_table.

If we try to enqueue at step 9, what happens?

A Element is added at rear=1

B front pointer moves forward

C Queue is full, enqueue rejected

D Queue becomes empty

💡 Hint

See 'Queue Full Check' operation and 'Visual State' at step 9 in execution_table.

Concept Snapshot

Circular Queue uses a fixed-size array with front and rear pointers.
Enqueue adds at rear, dequeue removes from front.
Pointers wrap around using modulo to reuse space.
Queue is empty when front and rear are -1.
Queue is full when next rear equals front.
Reset pointers when queue becomes empty after dequeue.

Full Transcript

This visualization shows how a circular queue works using an array. We start with front and rear pointers at -1, meaning the queue is empty. When we enqueue, if the queue is empty, front is set to 0. Rear moves forward to add elements. When rear reaches the end of the array, it wraps around to 0 using modulo operation. Dequeue removes elements from front and moves front forward similarly. When the last element is removed, front and rear reset to -1 to mark empty queue. The queue is full when the next rear position equals front, preventing further enqueue. This step-by-step trace helps understand how circular queues efficiently use array space by wrapping pointers.