Circular Queue Implementation Using Array in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue and dequeue operations?

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

enqueue(10), enqueue(20), enqueue(30), dequeue(), enqueue(40), enqueue(50), enqueue(60), dequeue(), enqueue(70)

What is the state of the queue from front to rear after these operations?

DSA Javascript

class CircularQueue {
  constructor(size) {
    this.size = size;
    this.queue = new Array(size);
    this.front = -1;
    this.rear = -1;
  }

  enqueue(value) {
    if ((this.rear + 1) % this.size === this.front) {
      return 'Queue is full';
    }
    if (this.front === -1) {
      this.front = 0;
    }
    this.rear = (this.rear + 1) % this.size;
    this.queue[this.rear] = value;
  }

  dequeue() {
    if (this.front === -1) {
      return 'Queue is empty';
    }
    const value = this.queue[this.front];
    if (this.front === this.rear) {
      this.front = -1;
      this.rear = -1;
    } else {
      this.front = (this.front + 1) % this.size;
    }
    return value;
  }

  printQueue() {
    if (this.front === -1) {
      return 'Queue is empty';
    }
    let result = [];
    let i = this.front;
    while (true) {
      result.push(this.queue[i]);
      if (i === this.rear) break;
      i = (i + 1) % this.size;
    }
    return result.join(' -> ') + ' -> null';
  }
}

const cq = new CircularQueue(5);
cq.enqueue(10);
cq.enqueue(20);
cq.enqueue(30);
cq.dequeue();
cq.enqueue(40);
cq.enqueue(50);
cq.enqueue(60);
cq.dequeue();
cq.enqueue(70);
console.log(cq.printQueue());

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

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

C 40 -> 50 -> 60 -> 70 -> null

D 30 -> 40 -> 50 -> 60 -> 70 -> null

💡 Hint

Remember that the circular queue wraps around when rear reaches the end of the array.

After the operations, the queue contains elements 30, 40, 50, 60, and 70 in order from front to rear. The dequeue operations remove 10 and then 20, so they are no longer in the queue.

❓ Predict Output

intermediate

What error occurs when enqueueing into a full circular queue?

Given a circular queue of size 3, the following operations are performed:

enqueue(1), enqueue(2), enqueue(3), enqueue(4)

What is the output or error after the last enqueue operation?

DSA Javascript

class CircularQueue {
  constructor(size) {
    this.size = size;
    this.queue = new Array(size);
    this.front = -1;
    this.rear = -1;
  }

  enqueue(value) {
    if ((this.rear + 1) % this.size === this.front) {
      return 'Queue is full';
    }
    if (this.front === -1) {
      this.front = 0;
    }
    this.rear = (this.rear + 1) % this.size;
    this.queue[this.rear] = value;
    return 'Enqueued ' + value;
  }
}

const cq = new CircularQueue(3);
console.log(cq.enqueue(1));
console.log(cq.enqueue(2));
console.log(cq.enqueue(3));
console.log(cq.enqueue(4));

A Queue is full

B Enqueued 4

C Queue is empty

D TypeError

💡 Hint

Check the condition that detects if the queue is full before adding a new element.

The circular queue is full when the next position of rear equals front. Trying to enqueue when full returns 'Queue is full'.

🔧 Debug

advanced

Identify the bug in this circular queue dequeue method

The following dequeue method is part of a circular queue implementation. It sometimes causes an infinite loop or incorrect front pointer update. What is the bug?

```js dequeue() { if (this.front === -1) { return 'Queue is empty'; } const value = this.queue[this.front]; if (this.front === this.rear) { this.front = -1; this.rear = -1; } else { this.front = this.front + 1 % this.size; } return value; } ```

A The method should set rear to front after dequeue, not -1.

B The expression this.front + 1 % this.size lacks parentheses, causing wrong precedence.

C The condition if (this.front === this.rear) should be if (this.front != this.rear).

D The method should not return value after dequeue.

💡 Hint

Operator precedence matters in arithmetic expressions.

Without parentheses, this.front + 1 % this.size is evaluated as this.front + (1 % this.size), which is incorrect. It should be (this.front + 1) % this.size to wrap correctly.

🚀 Application

advanced

How many elements can a circular queue of size N hold?

A circular queue is implemented using an array of size N. To distinguish between full and empty states, one slot is kept empty. What is the maximum number of elements that can be stored in this circular queue?

A N - 1

B N + 1

C N

D N / 2

💡 Hint

One slot is sacrificed to differentiate full and empty states.

To avoid confusion between full and empty, circular queue implementations keep one slot empty, so maximum elements stored is N - 1.

🧠 Conceptual

expert

Why is a circular queue preferred over a linear queue in fixed-size array implementations?

Choose the best reason why circular queues are preferred over linear queues when implemented using fixed-size arrays.

A Circular queues allow dynamic resizing of the array automatically.

B Circular queues are easier to implement than linear queues.

C Circular queues efficiently reuse empty spaces freed by dequeue operations, avoiding wasted space.

D Circular queues do not require front and rear pointers.

💡 Hint

Think about what happens when elements are dequeued in a linear queue.

In a linear queue, once rear reaches the end, no more elements can be enqueued even if there is space at the front. Circular queues wrap around and reuse that space.

Practice

1. What is the main advantage of using a circular queue over a simple linear queue when implemented using an array?

easy

A. It automatically sorts the elements in the queue.

B. It efficiently uses all available space by wrapping around the array.

C. It allows storing different data types in the queue.

D. It uses less memory than a linear queue.

Solution

1. Step 1: Understand linear queue limitation

   In a linear queue using an array, once the rear reaches the end, no more elements can be added even if there is free space at the front.

2. Step 2: Circular queue advantage

   A circular queue connects the end of the array back to the front, allowing reuse of free space and efficient use of the array.

3. Final Answer:

   It efficiently uses all available space by wrapping around the array. -> Option B

4. Quick Check:

   Circular queue = efficient space use [OK]

Hint: Circular queue reuses space by wrapping indices [OK]

Common Mistakes:

• Thinking circular queue sorts elements
• Believing it uses less memory than linear queue
• Assuming it allows mixed data types automatically

2. Which of the following is the correct way to check if a circular queue is full when using an array of size size with front and rear pointers?

easy

A. if (rear === size - 1)

B. if (rear === front)

C. if ((rear + 1) % size === front)

D. if (front === -1)

Solution

1. Step 1: Understand full condition in circular queue

   The queue is full when the next position of rear (rear + 1 modulo size) equals front, meaning no space to insert.

2. Step 2: Check each option

   if ((rear + 1) % size === front) correctly uses modulo to wrap around and compare with front. Others do not correctly represent full condition.

3. Final Answer:

   if ((rear + 1) % size === front) -> Option C

4. Quick Check:

   Full condition = (rear + 1) % size === front [OK]

Hint: Use modulo to wrap rear and compare with front [OK]

Common Mistakes:

• Checking rear === front for full (actually empty condition)
• Ignoring modulo wrap-around
• Using front === -1 to check full

3. Consider the following JavaScript code for a circular queue of size 5. What will be the output after these operations?

const size = 5;
let queue = new Array(size);
let front = -1, rear = -1;

function enqueue(value) {
  if ((rear + 1) % size === front) {
    console.log('Queue is full');
    return;
  }
  if (front === -1) front = 0;
  rear = (rear + 1) % size;
  queue[rear] = value;
}

enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
enqueue(50); // This enqueues successfully (queue now full)
console.log(queue);

medium

A. [10, 20, 30, 40, 50]

B. [10, 20, 30, 40, undefined]

C. [10, 20, 30, 40, null]

D. [undefined, 10, 20, 30, 40]

Solution

1. Step 1: Trace enqueue operations

   Initial: front=-1, rear=-1.
   enqueue(10): front=0, rear=0, queue[0]=10.
   enqueue(20): rear=1, queue[1]=20.
   enqueue(30): rear=2, queue[2]=30.
   enqueue(40): rear=3, queue[3]=40.
   enqueue(50): (rear+1)%5 = 4 === front 0? No, rear=4, queue[4]=50. No full printed.

2. Step 2: Verify output

   5 enqueues succeed for size 5. console.log(queue) shows [10, 20, 30, 40, 50].

3. Final Answer:

   [10, 20, 30, 40, 50] -> Option A

4. Quick Check:

   Full after exactly size enqueues [OK]

Hint: Check modulo full condition carefully to trace enqueue [OK]

Common Mistakes:

• Thinking queue full after 4 enqueues (5th fails)
• Confusing undefined and null values
• Ignoring front and rear initial values

4. The following code snippet for dequeue operation in a circular queue has a bug. What is the bug?

function dequeue() {
  if (front === -1) {
    console.log('Queue is empty');
    return null;
  }
  let value = queue[front];
  if (front === rear) {
    front = rear = -1;
  } else {
    front = front + 1;
  }
  return value;
}

medium

A. front should be updated using modulo to wrap around

B. rear should be incremented instead of front

C. The empty check should be rear === -1

D. The function should not return null when empty

Solution

1. Step 1: Analyze front update in dequeue

   When removing an element, front moves forward. Since queue is circular, front must wrap using modulo size.

2. Step 2: Identify bug in front update

   Code uses front = front + 1 without modulo, so front can go beyond array size causing errors.

3. Final Answer:

   front should be updated using modulo to wrap around -> Option A

4. Quick Check:

   Update front with modulo to avoid overflow [OK]

Hint: Always use modulo when moving front or rear in circular queue [OK]

Common Mistakes:

• Incrementing rear instead of front on dequeue
• Checking empty condition incorrectly
• Ignoring modulo wrap-around

5. You have a circular queue of size 4 implemented using an array. Initially, front = -1 and rear = -1. You perform these operations:

enqueue(1); enqueue(2); dequeue(); enqueue(3); enqueue(4); dequeue(); enqueue(5);

What is the final state of the queue array?

hard

A. [undefined, undefined, 3, 5]

B. [5, 2, 3, 4]

C. [undefined, 2, 3, 5]

D. [5, undefined, 3, 4]

Solution

1. Step 1: Trace each operation step-by-step

   Start: front=-1, rear=-1, queue=[undefined,undefined,undefined,undefined]
   enqueue(1): front=0, rear=0, queue=[1,undefined,undefined,undefined]
   enqueue(2): rear=1, queue=[1,2,undefined,undefined]
   dequeue(): value=queue[0]=1, front=1 (no clear), queue=[1,2,undefined,undefined]
   enqueue(3): rear=2, queue=[1,2,3,undefined]
   enqueue(4): rear=3, queue=[1,2,3,4]
   dequeue(): value=queue[1]=2, front=2 (no clear), queue=[1,2,3,4]
   enqueue(5): rear=0, queue[0]=5, queue=[5,2,3,4]

2. Step 2: Final queue array state

   queue=[5,2,3,4]
   front=2, rear=0. Dequeue does not clear slots; old values persist until overwritten. Position 1 skipped.

3. Final Answer:

   [5, undefined, 3, 4] -> Option D

4. Quick Check:

   Wrap-around enqueue updates index 0 after dequeues [OK]

Hint: Track front and rear carefully with modulo wrap [OK]

Common Mistakes:

• Not wrapping rear index on enqueue
• Assuming dequeue clears array slots to undefined
• Confusing front and rear after dequeues