Queue Implementation Using Array in DSA C++ - Execution Trace

Concept Flow - Queue Implementation Using Array

Start

↓

Check if queue is full?

Yes→Cannot enqueue, stop

No↓

Add element at rear index

↓

Update rear index (rear = (rear + 1) % size)

↓

Increment count

↓

Check if queue is empty?

Yes→Cannot dequeue, stop

No↓

Remove element at front index

↓

Update front index (front = (front + 1) % size)

↓

Decrement count

↓

Repeat operations as needed

This flow shows how elements are added at the rear and removed from the front in a circular array queue, updating indices and count accordingly.

Execution Sample

DSA C++

queue = ArrayQueue(5)
queue.enqueue(10)
queue.enqueue(20)
queue.dequeue()
queue.enqueue(30)

This code creates a queue of size 5, adds two elements, removes one, then adds another.

Execution Table

Step	Operation	Front Index	Rear Index	Count	Queue Array State	Visual State
1	Initialize queue	0	0	0	[_, _, _, _, _]	Empty queue
2	Enqueue 10	0	1	1	[10, _, _, _, _]	10 at rear=0
3	Enqueue 20	0	2	2	[10, 20, _, _, _]	20 at rear=1
4	Dequeue	1	2	1	[10, 20, _, _, _]	Removed 10 from front=0
5	Enqueue 30	1	3	2	[10, 20, 30, _, _]	30 at rear=2
6	Dequeue	2	3	1	[10, 20, 30, _, _]	Removed 20 from front=1
7	Enqueue 40	2	4	2	[10, 20, 30, 40, _]	40 at rear=3
8	Enqueue 50	2	0	3	[10, 20, 30, 40, 50]	50 at rear=4 (wrap around)
9	Enqueue 60 (Full)	2	0	3	[10, 20, 30, 40, 50]	Cannot enqueue, queue full
10	Dequeue	3	0	2	[10, 20, 30, 40, 50]	Removed 30 from front=2
11	Enqueue 60	3	1	3	[60, 20, 30, 40, 50]	60 at rear=0 (wrap around)
12	Dequeue	4	1	2	[60, 20, 30, 40, 50]	Removed 40 from front=3
13	Dequeue	0	1	1	[60, 20, 30, 40, 50]	Removed 50 from front=4 (wrap around)
14	Dequeue	1	1	0	[60, 20, 30, 40, 50]	Removed 60 from front=0
15	Dequeue (Empty)	1	1	0	[60, 20, 30, 40, 50]	Cannot dequeue, queue empty

💡 Execution stops when queue is full on enqueue or empty on dequeue.

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	Final
front	0	0	0	1	1	2	2	2	2	3	3	4	0	1	1
rear	0	1	2	2	3	3	4	0	0	0	1	1	1	1	1
count	0	1	2	1	2	1	2	3	3	2	3	2	1	0	0

Key Moments - 3 Insights

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

Because the queue uses a circular array, the rear index resets to 0 to reuse empty space at the start. See step 8 where rear moves from 4 to 0.

Why can't we enqueue when count equals the size of the array?

Count tracks how many elements are in the queue. When count equals size, the queue is full and no more elements can be added. See step 9 where enqueue is blocked.

Why does the front index move forward on dequeue but the array elements remain unchanged?

Dequeue moves front index to logically remove the element; the data stays in the array but is considered outside the queue. See step 4 where front moves from 0 to 1.

Visual Quiz - 3 Questions

Look at the execution table, what is the rear index after step 8?

A 0

B 4

C 3

D 2

💡 Hint

Check the 'Rear Index' column in row for step 8.

At which step does the queue become full and reject enqueue?

A Step 7

B Step 9

C Step 11

D Step 13

💡 Hint

Look for 'Cannot enqueue, queue full' in the 'Visual State' column.

If we dequeue at step 15, what will be the count value after?

A 1

B 0

C 2

D Cannot dequeue, queue empty

💡 Hint

See step 15 'Visual State' and 'Count' column for dequeue on empty queue.

Concept Snapshot

Queue using array stores elements in a circular manner.
Enqueue adds at rear, dequeue removes from front.
Front and rear indices wrap around using modulo.
Count tracks number of elements.
Queue is full when count == size, empty when count == 0.

Full Transcript

This visualization shows how a queue is implemented using an array with circular indexing. The front and rear pointers move forward and wrap around the array size. Enqueue adds elements at the rear index if the queue is not full, and dequeue removes elements from the front index if the queue is not empty. The count variable keeps track of how many elements are currently in the queue. When count equals the array size, the queue is full and cannot accept new elements. When count is zero, the queue is empty and cannot dequeue. The array elements remain in place but the logical queue moves by updating front and rear indices. This allows efficient use of space without shifting elements.

Practice

1. What is the main purpose of using an array to implement a queue?

easy

A. To store elements in a fixed-size linear order for FIFO operations

B. To store elements randomly for quick access

C. To sort elements automatically

D. To store elements in a LIFO order

Solution

1. Step 1: Understand queue behavior

   A queue follows FIFO (First In First Out), meaning elements are processed in the order they arrive.

2. Step 2: Role of array in queue

   An array stores elements in a fixed linear order, which helps maintain the FIFO order by using front and rear indices.

3. Final Answer:

   To store elements in a fixed-size linear order for FIFO operations -> Option A

4. Quick Check:

   Queue uses array for FIFO storage = C [OK]

Hint: Queue means FIFO; array stores elements linearly [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking array sorts elements automatically
• Assuming random access is main goal

2. Which of the following is the correct way to declare a queue array of size 5 in C++?

easy

A. array queue(5);

B. int queue[5];

C. int[5] queue;

D. queue int[5];

Solution

1. Step 1: Recall C++ array declaration syntax

   In C++, arrays are declared as: type name[size]; so int queue[5]; is correct.

2. Step 2: Check other options

   Options A, B, and C do not follow valid C++ syntax for array declaration.

3. Final Answer:

   int queue[5]; -> Option B

4. Quick Check:

   C++ array syntax = type name[size] [OK]

Hint: Remember C++ arrays: type name[size]; [OK]

Common Mistakes:

• Placing size before name
• Using wrong keywords like 'array'
• Incorrect order of type and name

3. What will be the output after performing these operations on an empty queue of size 3 implemented using array?
enqueue(10); enqueue(20); dequeue(); enqueue(30); display();
Assume enqueue adds at rear and dequeue removes from front.

medium

A. 10 -> 30 -> null

B. 10 -> 20 -> 30 -> null

C. 30 -> null

D. 20 -> 30 -> null

Solution

1. Step 1: Perform enqueue(10) and enqueue(20)

   Queue becomes: 10 -> 20 -> null

2. Step 2: Perform dequeue()

   Removes 10 from front, queue becomes: 20 -> null

3. Step 3: Perform enqueue(30)

   Add 30 at rear, queue becomes: 20 -> 30 -> null

4. Step 4: Display queue

   Output is: 20 -> 30 -> null

5. Final Answer:

   20 -> 30 -> null -> Option D

6. Quick Check:

   After dequeue and enqueue, queue = 20, 30 [OK]

Hint: Track front and rear after each operation [OK]

Common Mistakes:

• Not removing element on dequeue
• Adding new element at front instead of rear
• Confusing order of elements

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

int queue[3], front = -1, rear = -1;
void enqueue(int x) {
  if (rear == 3) {
    cout << "Queue Full";
    return;
  }
  rear++;
  queue[rear] = x;
  if (front == -1) front = 0;
}

medium

A. front should be incremented in enqueue

B. rear should be initialized to 0

C. Condition should be rear == 2 to check full queue

D. No error, code is correct

Solution

1. Step 1: Understand array indexing for size 3

   Array indices are 0, 1, 2. So rear should not exceed 2.

2. Step 2: Check condition for full queue

   Condition rear == 3 is wrong because index 3 is out of bounds. It should be rear == 2.

3. Final Answer:

   Condition should be rear == 2 to check full queue -> Option C

4. Quick Check:

   Array max index = size-1 = 2 [OK]

Hint: Array max index = size - 1, check boundary carefully [OK]

Common Mistakes:

• Using size instead of size-1 for index check
• Incrementing front in enqueue
• Initializing rear incorrectly

5. Given a queue implemented using an array of size 4, initially empty, what will be the state of the queue after these operations?
enqueue(5); enqueue(10); dequeue(); enqueue(15); enqueue(20); dequeue(); enqueue(25); display();
Assume no circular queue and enqueue fails if rear reaches size-1.

hard

A. 15 -> 20 -> null

B. 10 -> 15 -> 20 -> 25 -> null

C. 15 -> 20 -> 25 -> null

D. 5 -> 10 -> 15 -> 20 -> null

Solution

1. Step 1: Perform enqueue(5), enqueue(10)

   Queue: 5 -> 10 -> null; front=0, rear=1

2. Step 2: Perform dequeue()

   Remove 5; Queue: 10 -> null; front=1, rear=1

3. Step 3: Perform enqueue(15), enqueue(20)

   Queue: 10 -> 15 -> 20 -> null; front=1, rear=3

4. Step 4: Perform dequeue()

   Remove 10; Queue: 15 -> 20 -> null; front=2, rear=3

5. Step 5: Perform enqueue(25)

   rear=3 (max index), cannot enqueue 25; operation fails, queue unchanged

6. Step 6: Display queue

   Queue elements from front=2 to rear=3: 15 -> 20 -> null

7. Final Answer:

   15 -> 20 -> null -> Option A

8. Quick Check:

   Check enqueue failure at full rear index [OK]

Hint: No circular queue means no wrap-around; watch rear limit [OK]

Common Mistakes:

• Assuming enqueue works after rear reaches max
• Not updating front after dequeue
• Confusing queue order after operations