Circular Queue Implementation Using Array in DSA C# - Execution Trace

Concept Flow - Circular Queue Implementation Using Array

Initialize queue array and pointers

↓

Enqueue: Check if queue is full?

Yes→Reject enqueue

No↓

Add element at rear

↓

Update rear pointer circularly

↓

Dequeue: Check if queue is empty?

Yes→Reject dequeue

No↓

Remove element at front

↓

Update front pointer circularly

↓

Repeat operations as needed

This flow shows how elements are added and removed in a circular queue using an array, updating pointers circularly to reuse space.

Execution Sample

DSA C#

int[] queue = new int[3];
int front = -1, rear = -1;

// Enqueue 10
// Enqueue 20
// Dequeue
// Enqueue 30
// Enqueue 40

This code enqueues 10 and 20, dequeues one element, then enqueues 30 and 40 in a circular queue of size 3.

Execution Table

Step	Operation	Front Pointer	Rear Pointer	Queue Array State	Visual State
1	Initialize queue	-1	-1	[_, _, _]	Queue empty
2	Enqueue 10	0	0	[10, _, _]	10 -> _ -> _ (front=0, rear=0)
3	Enqueue 20	0	1	[10, 20, _]	10 -> 20 -> _ (front=0, rear=1)
4	Dequeue	1	1	[10, 20, _]	10 removed, front=1, rear=1, queue: 20 -> _
5	Enqueue 30	1	2	[10, 20, 30]	20 -> 30 -> _ (front=1, rear=2)
6	Enqueue 40	1	0	[40, 20, 30]	20 -> 30 -> 40 (front=1, rear=0)
7	Attempt Enqueue 50	1	0	[40, 20, 30]	Queue full, enqueue rejected

💡 Step 7 stops because the queue is full (rear+1 mod size == front)

Variable Tracker

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

Key Moments - 3 Insights

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

Because the queue is circular, when rear reaches the last index, it wraps to 0 to reuse empty space at the start, as shown in Step 6 where rear moves from 2 to 0.

Why can't we enqueue when (rear + 1) % size equals front?

This condition means the queue is full. Step 7 shows enqueue rejected because rear+1 mod size equals front, so no space is left to add new elements.

Why does front move forward on dequeue but the old value remains in the array?

The old value stays until overwritten. The front pointer moves to the next element logically removing the old front. Step 4 shows front moving from 0 to 1, but array still has old 10.

Visual Quiz - 3 Questions

Look at the execution table at Step 4. What is the value of front and rear pointers after dequeue?

A front=0, rear=1

B front=1, rear=1

C front=1, rear=0

D front=0, rear=0

💡 Hint

Check the 'Front Pointer' and 'Rear Pointer' columns in Step 4 of the execution table.

At which step does the rear pointer wrap around to the start of the array?

A Step 3

B Step 4

C Step 6

D Step 7

💡 Hint

Look at the 'Rear Pointer' values and 'Queue Array State' in the execution table.

If the queue size was increased to 4, what would happen at Step 7?

A Enqueue 50 would succeed

B Enqueue 50 would still be rejected

C Dequeue would be forced

D Queue would reset

💡 Hint

Refer to the exit note and understand the full condition for enqueue rejection.

Concept Snapshot

Circular Queue using array:
- Use front and rear pointers
- Enqueue at rear, dequeue at front
- Pointers wrap using modulo: (index + 1) % size
- Queue full if (rear + 1) % size == front
- Queue empty if front == -1

Full Transcript

This visual trace shows a circular queue implemented with an array of size 3. Initially, front and rear pointers are -1 indicating empty queue. Enqueue operations add elements at rear and update rear pointer circularly. Dequeue removes element at front and moves front pointer forward. When rear reaches the end of the array, it wraps to 0 to reuse space. The queue is full when the next rear position equals front, preventing further enqueues. The array may hold old values after dequeue until overwritten. This trace helps understand pointer movements and queue state changes step-by-step.

Practice

1. What is the main advantage of using a circular queue over a simple linear queue when implemented using an array?

easy

A. It efficiently uses the array space by reusing freed slots.

B. It allows storing different data types in the same queue.

C. It automatically sorts the elements in the queue.

D. It increases the maximum size of the queue beyond the array length.

Solution

1. Step 1: Understand linear queue limitation

   In a linear queue using an array, once the rear reaches the end, no more elements can be added even if there are empty slots at the front.

2. Step 2: Circular queue advantage

   A circular queue treats the array as circular, so when rear reaches the end, it wraps around to use empty slots at the front, efficiently using all available space.

3. Final Answer:

   It efficiently uses the array space by reusing freed slots. -> Option A

4. Quick Check:

   Circular queue reuses space = Advantage A [OK]

Hint: Circular queue reuses space freed at front [OK]

Common Mistakes:

• Thinking circular queue increases array size
• Believing it sorts elements automatically
• Assuming it stores different data types

2. Which of the following is the correct condition to check if a circular queue is full when using an array of size n with front and rear indices?

easy

A. rear == n

B. rear == front

C. (rear + 1) % n == front

D. front == 0 && rear == n - 1

Solution

1. Step 1: Understand circular queue full condition

   In a circular queue, the queue is full when the next position of rear (circularly) is front.

2. Step 2: Express condition mathematically

   This means (rear + 1) modulo n equals front, ensuring no overlap and full queue detection.

3. Final Answer:

   (rear + 1) % n == front -> Option C

4. Quick Check:

   Full if next rear equals front = D [OK]

Hint: Full when next rear wraps to front [OK]

Common Mistakes:

• Using rear == front as full (actually empty)
• Checking rear == n ignoring wrap-around
• Using front == 0 && rear == n - 1 only (linear queue)

3. Consider a circular queue of size 5 (indices 0 to 4). Initially, front = 0 and rear = 3. After performing Enqueue(10) and Dequeue(), what are the values of front and rear?

medium

A. front = 0, rear = 4

B. front = 1, rear = 3

C. front = 0, rear = 3

D. front = 1, rear = 4

Solution

1. Step 1: Perform Enqueue operation

   Enqueue increments rear circularly: rear = (3 + 1) % 5 = 4.

2. Step 2: Perform Dequeue operation

   Dequeue increments front circularly: front = (0 + 1) % 5 = 1.

3. Final Answer:

   front = 1, rear = 4 -> Option D

4. Quick Check:

   Enqueue rear+1=4, Dequeue front+1=1 [OK]

Hint: Increment indices modulo size after enqueue/dequeue [OK]

Common Mistakes:

• Not wrapping indices with modulo
• Updating front on enqueue or rear on dequeue
• Confusing initial and final index values

4. Given this snippet of circular queue code, what is the error?

int n = 5;
int front = 0, rear = 0;
int[] queue = new int[n];

// Enqueue operation
rear = (rear + 1) % n;
queue[rear] = 10;

// Dequeue operation
front = (front + 1) % n;
int x = queue[front];

// Check if queue is empty
if (front == rear)
    Console.WriteLine("Queue is empty");

medium

A. The enqueue operation increments rear before inserting, causing off-by-one error.

B. The initial values of front and rear cause the first enqueue to overwrite data.

C. The empty check condition is incorrect; it should be (rear + 1) % n == front.

D. The dequeue operation should decrement front instead of incrementing.

Solution

1. Step 1: Analyze enqueue operation

   Incrementing rear before inserting means the first element is placed at index 1, skipping index 0, which wastes space and causes off-by-one errors.

2. Step 2: Understand correct enqueue logic

   Enqueue should insert at current rear, then increment rear after insertion or handle indices carefully to avoid skipping slots.

3. Final Answer:

   The enqueue operation increments rear before inserting, causing off-by-one error. -> Option A

4. Quick Check:

   Increment rear before insert = off-by-one error B [OK]

Hint: Insert before incrementing rear to avoid skipping slots [OK]

Common Mistakes:

• Confusing empty and full conditions
• Incrementing front on enqueue or rear on dequeue
• Ignoring initial index positions

5. You have a circular queue of size 6. Initially, front = 4 and rear = 2. The queue currently holds 4 elements. Which of the following sequences of operations will cause the queue to become full?

hard

A. Enqueue three times, then dequeue once, then enqueue once.

B. Dequeue once, then enqueue three times.

C. Enqueue three times without any dequeue.

D. Dequeue twice, then enqueue five times.

Solution

1. Step 1: Calculate current queue state

   Size is 6, front=4, rear=2, holding 4 elements means the queue is partially filled with wrap-around.

2. Step 2: Analyze each operation sequence

   A: Dequeue once (remove 1), enqueue three times (add 3) -> net +2 elements, total 6 (full). B: Enqueue three times (add 3), dequeue once (remove 1), enqueue once (add 1) -> net +3 elements, total 7 (overflow). C: Enqueue three times without dequeue would overflow (since only 2 slots free). D: Dequeue twice (remove 2), enqueue five times (add 5) -> net +3 elements, total 7 (overflow).

3. Step 3: Identify which sequence is valid without overflow

   Only Dequeue once, then enqueue three times. correctly balances operations to reach full without overflow errors.

4. Final Answer:

   Dequeue once, then enqueue three times. -> Option B

5. Quick Check:

   Dequeue 1 + Enqueue 3 fills queue = A [OK]

Hint: Track net enqueue minus dequeue to reach full capacity [OK]

Common Mistakes:

• Ignoring wrap-around effect on indices
• Assuming enqueue always succeeds without checking full
• Miscounting elements after operations