Queue Implementation Using Array in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a queue in data structures?

A queue is a collection where elements are added at the back and removed from the front, following the First-In-First-Out (FIFO) order.

beginner

How does an array-based queue keep track of elements?

It uses two pointers or indices: front to track the first element and rear to track the position where the next element will be added in the queue within the array.

intermediate

What happens when the rear index reaches the end of the array in a simple queue implementation?

The queue is considered full and cannot add more elements, even if there is space at the front due to dequeued elements. This is called the queue overflow problem in simple array queues.

beginner

Explain the enqueue operation in a queue implemented using an array.

Enqueue adds an element at the position pointed by rear and then moves the rear pointer forward by one, if there is space available.

intermediate

What is the main limitation of a simple array-based queue and how can it be improved?

The main limitation is that once rear reaches the end, no more elements can be added even if there is space at the front. This can be improved by using a circular queue where rear wraps around to the start of the array.

In a queue implemented using an array, which pointer indicates where the next element will be removed from?

A front

B rear

C middle

D start

The front pointer indicates the position of the element to be removed next.

What happens if you try to enqueue an element when the queue is full in a simple array queue?

A Queue overflow error occurs

B The queue automatically resizes

C The element is added at the front

D The rear pointer moves backward

In a simple array queue, if the queue is full, enqueue operation cannot add elements and causes overflow.

Which of the following best describes the order of elements in a queue?

A Last-In-First-Out

B Random order

C First-In-First-Out

D Sorted order

Queue follows First-In-First-Out (FIFO) order.

In an array-based queue, what does the rear pointer represent?

A Position of the first element

B Size of the queue

C Position of the last element removed

D Position where next element will be added

The rear pointer shows where the next element will be inserted.

How can the limitation of wasted space in a simple array queue be solved?

A By using a linked list

B By using a circular queue

C By increasing the array size dynamically

D By resetting the front pointer to zero

A circular queue allows the rear pointer to wrap around, reusing empty space at the front.

Describe how enqueue and dequeue operations work in a queue implemented using an array.

Think about where elements enter and leave the queue.

Explain the problem of overflow in a simple array queue and how a circular queue solves it.

Consider what happens when the array end is reached but there is free space at the beginning.

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