Queue Implementation Using Array in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue and dequeue operations?

Consider a queue implemented using an array with a fixed size of 5. Initially, the queue is empty. The following operations are performed in order:

Enqueue 10, Enqueue 20, Enqueue 30, Dequeue, Enqueue 40, Enqueue 50, Dequeue, Enqueue 60.

What is the state of the queue after these operations?

DSA C#

class Queue {
    private int[] arr = new int[5];
    private int front = 0;
    private int rear = 0;
    private int count = 0;

    public void Enqueue(int val) {
        if (count == arr.Length) return;
        arr[rear] = val;
        rear = (rear + 1) % arr.Length;
        count++;
    }

    public int Dequeue() {
        if (count == 0) return -1;
        int val = arr[front];
        front = (front + 1) % arr.Length;
        count--;
        return val;
    }

    public string PrintQueue() {
        string result = "";
        for (int i = 0; i < count; i++) {
            int index = (front + i) % arr.Length;
            result += arr[index] + " -> ";
        }
        return result + "null";
    }
}

Queue q = new Queue();
q.Enqueue(10);
q.Enqueue(20);
q.Enqueue(30);
q.Dequeue();
q.Enqueue(40);
q.Enqueue(50);
q.Dequeue();
q.Enqueue(60);
Console.WriteLine(q.PrintQueue());

A 10 -> 20 -> 30 -> 40 -> 50 -> null

B 20 -> 30 -> 40 -> 50 -> 60 -> null

C 30 -> 40 -> 50 -> 60 -> null

D 40 -> 50 -> 60 -> null

💡 Hint

Track the front and rear pointers carefully after each operation.

After the first three enqueues, queue is 10 -> 20 -> 30 -> null. Dequeue removes 10, queue becomes 20 -> 30 -> null. Enqueue 40 and 50 adds them at rear: 20 -> 30 -> 40 -> 50 -> null. Dequeue removes 20, queue is 30 -> 40 -> 50 -> null. Enqueue 60 adds at rear: 30 -> 40 -> 50 -> 60 -> null.

🧠 Conceptual

intermediate

What happens when the queue is full in array implementation?

In a queue implemented using a fixed-size array, what happens if you try to enqueue an element when the queue is already full?

A The enqueue operation is ignored or rejected because the queue is full.

B The queue automatically resizes to accommodate more elements.

C The oldest element is removed automatically to make space for the new element.

D The enqueue operation overwrites the last element in the queue.

💡 Hint

Think about fixed size arrays and their capacity limits.

A fixed-size array cannot grow dynamically. When full, enqueue operations must be rejected or ignored to avoid overwriting data.

🔧 Debug

advanced

Identify the bug in this dequeue method

What error will occur when running this dequeue method in a queue implemented using an array?

DSA C#

public int Dequeue() {
    if (count == 0) return -1;
    int val = arr[front];
    front = front + 1;
    count--;
    return val;
}

A IndexOutOfRangeException when front exceeds array length.

B No error; method works correctly.

C NullReferenceException because arr is null.

D StackOverflowException due to infinite recursion.

💡 Hint

Consider what happens when front increments beyond the array size.

The front index is incremented without wrapping around using modulo. When front exceeds array length, accessing arr[front] causes IndexOutOfRangeException.

❓ Predict Output

advanced

Output of circular queue after wrap-around enqueues and dequeues

Given a circular queue of size 4 implemented with an array, starting empty, perform these operations:

Enqueue 1, Enqueue 2, Enqueue 3, Dequeue, Enqueue 4, Dequeue, Enqueue 5.

What is the printed queue state?

DSA C#

class CircularQueue {
    private int[] arr = new int[4];
    private int front = 0;
    private int rear = 0;
    private int count = 0;

    public void Enqueue(int val) {
        if (count == arr.Length) return;
        arr[rear] = val;
        rear = (rear + 1) % arr.Length;
        count++;
    }

    public int Dequeue() {
        if (count == 0) return -1;
        int val = arr[front];
        front = (front + 1) % arr.Length;
        count--;
        return val;
    }

    public string PrintQueue() {
        string result = "";
        for (int i = 0; i < count; i++) {
            int index = (front + i) % arr.Length;
            result += arr[index] + " -> ";
        }
        return result + "null";
    }
}

CircularQueue q = new CircularQueue();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Dequeue();
q.Enqueue(4);
q.Dequeue();
q.Enqueue(5);
Console.WriteLine(q.PrintQueue());

A 1 -> 2 -> 3 -> 4 -> null

B 2 -> 3 -> 4 -> 5 -> null

C 4 -> 5 -> null

D 3 -> 4 -> 5 -> null

💡 Hint

Remember the circular wrap-around of front and rear pointers.

After enqueuing 1,2,3 queue is 1->2->3->null. Dequeue removes 1, queue is 2->3->null. Enqueue 4 adds at rear: 2->3->4->null. Dequeue removes 2, queue is 3->4->null. Enqueue 5 adds at rear (wrap-around): 3->4->5->null.

🧠 Conceptual

expert

Why use circular queue instead of simple array queue?

Why is a circular queue implementation preferred over a simple array queue implementation when using a fixed-size array?

A Circular queue automatically resizes the array when full.

B Circular queue efficiently reuses empty spaces created by dequeues, avoiding wasted space.

C Circular queue allows multiple threads to enqueue and dequeue simultaneously without locks.

D Circular queue stores elements in sorted order automatically.

💡 Hint

Think about what happens to space when elements are dequeued in a simple array queue.

In a simple array queue, dequeued elements leave empty space at the front that cannot be reused, causing inefficient space use. Circular queue uses modulo arithmetic to wrap around and reuse space.

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