Queue Implementation Using Array in DSA C# - Execution Trace

Concept Flow - Queue Implementation Using Array

Initialize array with fixed size

↓

Set front = -1, rear = -1

↓

Enqueue operation?

Yes→Check if queue is full

↓

Add element at rear+1

↓

Update rear pointer

↓

If front == -1, set front = 0

↓

Done

No↓

Dequeue operation?

Yes→Check if queue is empty

↓

Remove element at front

↓

Update front pointer front+1

↓

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

↓

Done

No↓

Exit or wait for next operation

This flow shows how a queue uses an array with front and rear pointers to add (enqueue) and remove (dequeue) elements while checking for full or empty conditions.

Execution Sample

DSA C#

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

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

This code shows enqueue and dequeue operations on a queue implemented with an array of size 3.

Execution Table

Step	Operation	Front	Rear	Queue Array State	Pointer Changes	Visual State
1	Initialize queue	-1	-1	[_, _, _]	front = -1, rear = -1	Queue is empty
2	Enqueue 10	0	0	[10, _, _]	rear: -1 -> 0; front: -1 -> 0	10 -> null
3	Enqueue 20	0	1	[10, 20, _]	rear: 0 -> 1	10 -> 20 -> null
4	Dequeue	1	1	[10, 20, _]	front: 0 -> 1	20 -> null
5	Enqueue 30	1	2	[10, 20, 30]	rear: 1 -> 2	20 -> 30 -> null
6	Attempt Enqueue 40	1	2	[10, 20, 30]	No change (Queue Full)	20 -> 30 -> null
7	Dequeue	2	2	[10, 20, 30]	front: 1 -> 2	30 -> null
8	Dequeue	-1	-1	[10, 20, 30]	front: 2 -> -1; rear: 2 -> -1	Queue is empty
9	Attempt Dequeue	-1	-1	[10, 20, 30]	No change (Queue Empty)	Queue is empty

💡 Execution stops after queue is empty and no further operations are performed.

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	Final
front	-1	0	0	1	1	1	2	-1	-1
rear	-1	0	1	1	2	2	2	-1	-1
queue array	[_, _, _]	[10, _, _]	[10, 20, _]	[10, 20, _]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]

Key Moments - 3 Insights

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

Because dequeue only moves the front pointer to the next element (see Step 4 and Step 7 in execution_table). The old value stays in the array but is considered outside the queue.

Why do we reset front and rear to -1 when the queue becomes empty?

Resetting front and rear to -1 (see Step 8) marks the queue as empty and ready for new enqueue operations, avoiding confusion with leftover pointers.

Why can't we enqueue when rear reaches the last index even if front has moved forward?

Because this simple array queue does not reuse freed space at the front (see Step 6). The queue is full when rear is at the last index, even if front > 0.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of front after Step 4 (Dequeue)?

A 0

B 1

C -1

D 2

💡 Hint

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

At which step does the queue become empty again after initial enqueues?

A Step 6

B Step 7

C Step 8

D Step 9

💡 Hint

Look for when both front and rear reset to -1 in execution_table.

If the array size was increased to 4, which step would allow enqueueing 40 successfully?

A Step 6

B Step 5

C Step 7

D Step 9

💡 Hint

Step 6 shows enqueue failing due to full queue; with larger array, it would succeed.

Concept Snapshot

Queue using array:
- Use fixed-size array with front and rear pointers
- Enqueue: add at rear+1 if not full
- Dequeue: remove from front and move front forward
- Reset front and rear to -1 when empty
- Simple queue does not reuse freed space (no wrap-around)

Full Transcript

This visualization shows how a queue is implemented using an array with fixed size. The queue uses two pointers: front and rear. Initially, both are set to -1 to indicate the queue is empty. When we enqueue, we check if the queue is full by comparing rear with the last index. If not full, we add the element at rear+1 and update rear. If front was -1, we set it to 0 to mark the start. When we dequeue, we check if the queue is empty by seeing if front is -1. If not empty, we remove the element at front and move front forward. If front passes rear, we reset both to -1 to mark empty. This simple array queue does not reuse space freed at the front, so once rear reaches the end, no more enqueues are possible until dequeues free space. The execution table tracks each step, showing pointer changes and the queue's visual state as elements are added and removed.

Practice

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

easy

A. It removes elements from the end only.

B. It allows random access to elements.

C. It stores elements in sorted order automatically.

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

Solution

1. Step 1: Understand queue behavior

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

2. Step 2: Compare options with queue properties

   Only It follows First-In-First-Out (FIFO) order. correctly describes FIFO behavior; others describe different data structures or incorrect behavior.

3. Final Answer:

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

4. Quick Check:

   Queue = FIFO order [OK]

Hint: Remember queue = first in, first out [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 queue array of size 5 in C#?

easy

A. int queue = new int[5];

B. int queue[] = new int(5);

C. int[] queue = new int[5];

D. int[] queue = int[5];

Solution

1. Step 1: Recall C# array declaration syntax

   In C#, arrays are declared as type[] name = new type[size];

2. Step 2: Check each option

   int[] queue = new int[5]; matches correct syntax; others have syntax errors or wrong usage.

3. Final Answer:

   int[] queue = new int[5]; -> Option C

4. Quick Check:

   C# array declaration = int[] name = new int[size] [OK]

Hint: Use type[] name = new type[size] for arrays [OK]

Common Mistakes:

• Missing [] after type
• Using parentheses instead of brackets
• Assigning array without new keyword

3. Consider this C# code for a queue using an array of size 3:

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

// Enqueue 10
rear++;
queue[rear] = 10;
if(front == -1) front = 0;

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

// Dequeue
int val = queue[front];
front++;

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

// Current queue elements from front to rear?

medium

A. [10, 20, 30]

B. [20, 30]

C. [30]

D. [10, 30]

Solution

1. Step 1: Trace enqueue and dequeue operations

   Enqueue 10: rear=0, front=0, queue=[10,_,_] Enqueue 20: rear=1, queue=[10,20,_] Dequeue: val=queue[front]=10, front=1 Enqueue 30: rear=2, queue=[10,20,30]

2. Step 2: Identify current queue elements

   Front=1, rear=2, so elements are queue[1]=20 and queue[2]=30

3. Final Answer:

   [20, 30] -> Option B

4. Quick Check:

   After dequeue front=1, queue elements = [20, 30] [OK]

Hint: Track front and rear indexes carefully [OK]

Common Mistakes:

• Not updating front after dequeue
• Including dequeued elements in output
• Confusing front and rear positions

4. What is the error in this queue enqueue method using array?

void Enqueue(int[] queue, ref int rear, int value, int size) {
  if (rear == size) {
    Console.WriteLine("Queue is full");
    return;
  }
  rear++;
  queue[rear] = value;
}

medium

A. rear should be checked against size - 1, not size.

B. rear should be incremented after assigning value.

C. The method should check if rear is less than zero.

D. The queue array should be resized inside the method.

Solution

1. Step 1: Analyze boundary check for full queue

   Array indices go from 0 to size-1, so rear == size means out of bounds.

2. Step 2: Correct condition for full queue

   Check if rear == size - 1 before enqueue to avoid overflow.

3. Final Answer:

   rear should be checked against size - 1, not size. -> Option A

4. Quick Check:

   Array max index = size - 1 [OK]

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

Common Mistakes:

• Checking rear == size causes index out of range
• Incrementing rear before check
• Ignoring array bounds in enqueue

5. You want to implement a circular queue using an array of size 4. Initially, front = -1 and rear = -1. After these operations:

Enqueue(5)
Enqueue(10)
Enqueue(15)
Dequeue()
Enqueue(20)
Enqueue(25)

What will be the state of the queue array and the values of front and rear?

hard

A. Queue: [25, 10, 15, 20], front=1, rear=0

B. Queue: [5, 10, 15, 20], front=0, rear=3

C. Queue: [20, 25, 15, 10], front=2, rear=1

D. Queue: [10, 15, 20, 25], front=0, rear=3

Solution

1. Step 1: Perform each operation with circular logic

   Enqueue 5: front=0, rear=0, queue=[5,_,_,_] Enqueue 10: rear=1, queue=[5,10,_,_] Enqueue 15: rear=2, queue=[5,10,15,_] Dequeue: front=1 (removed 5) Enqueue 20: rear=3, queue=[5,10,15,20] Enqueue 25: rear wraps to 0, queue=[25,10,15,20]

2. Step 2: Final front and rear positions

   front=1, rear=0, queue array = [25,10,15,20]

3. Final Answer:

   Queue: [25, 10, 15, 20], front=1, rear=0 -> Option A

4. Quick Check:

   Circular queue wraps rear index [OK]

Hint: Remember rear wraps to 0 in circular queue [OK]

Common Mistakes:

• Not wrapping rear index after reaching end
• Not updating front after dequeue
• Assuming linear queue behavior