Queue Implementation Using Array in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Enqueue and Dequeue Operations

What is the printed state of the queue after the following operations?

DSA Java

QueueArray queue = new QueueArray(5);
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
queue.dequeue();
queue.enqueue(40);
queue.printQueue();

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

B 20 -> 30 -> 40 -> null

C 30 -> 40 -> null

D 20 -> 30 -> null

💡 Hint

Remember that dequeue removes the front element and enqueue adds to the rear.

Initially, 10, 20, 30 are enqueued. Dequeue removes 10. Then 40 is enqueued. The queue now has 20, 30, 40.

🧠 Conceptual

intermediate

Queue Full Condition in Array Implementation

In a queue implemented using a fixed-size array, which condition correctly checks if the queue is full?

A rear == size - 1

B front == rear

C front == 0 && rear == size - 1

D rear == front - 1

💡 Hint

Think about when the queue cannot accept more elements in a simple array implementation.

In a simple array queue, the queue is full when rear is at the last index (size - 1) and front is at 0.

🔧 Debug

advanced

Identify the Error in Dequeue Method

What error will occur when running this dequeue method if the queue is empty?

DSA Java

public int dequeue() {
  if (front == -1 || front > rear) {
    System.out.println("Queue is empty");
  }
  int element = queue[front];
  front++;
  return element;
}

A ArrayIndexOutOfBoundsException

B Returns garbage value

C No error, returns correct element

D NullPointerException

💡 Hint

Check what happens if front is -1 or greater than rear but method continues.

If the queue is empty, the method prints a message but still accesses queue[front], which is invalid and causes ArrayIndexOutOfBoundsException.

❓ Predict Output

advanced

Output After Multiple Enqueue and Dequeue

What is the queue state after these operations on a queue of size 5? enqueue(5), enqueue(10), dequeue(), enqueue(15), enqueue(20), dequeue(), enqueue(25), printQueue()

DSA Java

QueueArray queue = new QueueArray(5);
queue.enqueue(5);
queue.enqueue(10);
queue.dequeue();
queue.enqueue(15);
queue.enqueue(20);
queue.dequeue();
queue.enqueue(25);
queue.printQueue();

A 15 -> 20 -> 25 -> null

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

C 5 -> 10 -> 15 -> 20 -> null

D 20 -> 25 -> null

💡 Hint

Track front and rear carefully after each operation.

After first dequeue, 5 is removed; after second dequeue, 10 is removed; enqueues add 15, 20, 25. Final queue is 15, 20, 25.

🧠 Conceptual

expert

Limitation of Simple Array Queue and Its Solution

What is the main limitation of a simple queue implemented using an array and how is it commonly solved?

A Limitation: Fixed size; Solution: Use dynamic array

B Limitation: Slow enqueue; Solution: Use linked list

C Limitation: Cannot dequeue; Solution: Use stack instead

D Limitation: Wasted space after dequeues; Solution: Use circular queue

💡 Hint

Think about what happens to the front index after many dequeues.

In a simple array queue, after dequeues, front moves forward leaving unused space at the start. Circular queue reuses this space by wrapping rear to start.

Practice

1. What is the main purpose of using an array in a queue implementation?

easy

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

B. To allow random access to elements anywhere in the queue

C. To sort elements automatically when inserted

D. To store elements in a tree structure

Solution

1. Step 1: Understand queue storage

   A queue stores elements in order, so an array can hold them in a fixed linear sequence.

2. Step 2: Compare other options

   Random access and sorting are not queue properties; tree structure is unrelated.

3. Final Answer:

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

4. Quick Check:

   Queue uses array for linear storage [OK]

Hint: Queue uses array for fixed linear storage [OK]

Common Mistakes:

• Thinking queue allows random access
• Assuming array sorts elements automatically
• Confusing queue with tree structures

2. Which of the following is the correct way to check if a queue implemented using an array is empty?

easy

A. if (front == rear) return true;

B. if (rear == size) return true;

C. if (front == -1) return true;

D. if (front > rear) return true;

Solution

1. Step 1: Understand empty queue condition

   In array queue, front = -1 means no elements have been enqueued yet.

2. Step 2: Analyze other conditions

   front == rear means queue is full or empty depending on implementation; rear == size means full; front > rear is invalid.

3. Final Answer:

   if (front == -1) return true; -> Option C

4. Quick Check:

   Empty queue check uses front == -1 [OK]

Hint: Empty queue usually has front at -1 [OK]

Common Mistakes:

• Using front == rear to check empty (can be full)
• Checking rear == size for empty instead of full
• Using front > rear which is invalid

3. What will be the output after the following operations on a queue of size 5 implemented using an array?

enqueue(10); enqueue(20); dequeue(); enqueue(30); enqueue(40); dequeue(); enqueue(50); display();

medium

A. 30 -> 40 -> 50 -> null

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

C. 10 -> 20 -> 30 -> 40 -> 50 -> null

D. 40 -> 50 -> null

Solution

1. Step 1: Trace enqueue and dequeue operations

   enqueue(10), enqueue(20) adds 10,20; dequeue removes 10; enqueue(30), enqueue(40) adds 30,40; dequeue removes 20; enqueue(50) adds 50.

2. Step 2: Determine queue content after operations

   Remaining elements are 30, 40, 50 in order.

3. Final Answer:

   30 -> 40 -> 50 -> null -> Option A

4. Quick Check:

   Queue after operations = 30,40,50 [OK]

Hint: Track enqueue/dequeue stepwise to find queue content [OK]

Common Mistakes:

• Not removing correct elements on dequeue
• Assuming queue resets after full
• Confusing order of elements after operations

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

if (rear == size) {
  System.out.println("Queue is full");
} else {
  rear++;
  queue[rear] = value;
}

medium

A. rear should be incremented after assigning value

B. queue array size is not checked before insertion

C. front pointer is not updated when queue is empty

D. Condition should be rear == size - 1 to check full

Solution

1. Step 1: Analyze full queue condition

   Array index goes from 0 to size-1, so rear == size means out of bounds; full condition is rear == size - 1.

2. Step 2: Check rear increment and assignment

   Incrementing rear before assignment is correct if rear starts at -1.

3. Final Answer:

   Condition should be rear == size - 1 to check full -> Option D

4. Quick Check:

   Full queue check uses rear == size - 1 [OK]

Hint: Array index max is size - 1, not size [OK]

Common Mistakes:

• Checking rear == size instead of size - 1
• Incrementing rear after assignment causing overwrite
• Ignoring front pointer update on empty queue

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); enqueue(25); dequeue(); enqueue(30); display();

Assume the queue does not support circular wrapping and front and rear start at -1.

hard

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

B. Queue Overflow error occurs

C. 20 -> 25 -> 30 -> null

D. 15 -> 20 -> 25 -> null

Solution

1. Step 1: Trace each operation stepwise

   enqueue(5) adds 5; enqueue(10) adds 10; dequeue removes 5; enqueue(15) adds 15; enqueue(20) adds 20; enqueue(25) attempts to add but queue size is 4 and rear is at last index.

2. Step 2: Check for overflow due to no circular wrap

   Since queue is full at rear index 3, enqueue(25) causes overflow; subsequent operations cannot proceed.

3. Final Answer:

   Queue Overflow error occurs -> Option B

4. Quick Check:

   No circular wrap causes overflow at full array [OK]

Hint: Without circular queue, overflow occurs when rear reaches end [OK]

Common Mistakes:

• Assuming queue wraps around without circular logic
• Ignoring overflow condition on enqueue
• Miscounting elements after dequeue