Circular Queue Implementation Using Array in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the front pointer of the circular queue.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

A-1

Bnull

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting front to -1 or null which is incorrect for initialization.

The front pointer starts at 0 to indicate the first position in the queue.

2fill in blank

medium

Complete the code to check if the circular queue is full.

DSA Javascript

isFull() {
  return this.count [1] this.size;
}

Drag options to blanks, or click blank then click option'

A<

B===

C>

D!==

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than or not equal operators which give wrong results.

The queue is full when the count of elements equals the size of the queue.

3fill in blank

hard

Fix the error in updating the rear pointer after enqueue operation.

DSA Javascript

enqueue(element) {
  if (this.isFull()) {
    throw new Error('Queue is full');
  }
  this.rear = (this.rear [1] 1) % this.size;
  this.queue[this.rear] = element;
  this.count++;
}

Drag options to blanks, or click blank then click option'

A/

B-

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication which breaks the circular logic.

To move rear forward circularly, add 1 and take modulo size.

4fill in blank

hard

Fill both blanks to correctly update the front pointer after dequeue operation and decrease count.

DSA Javascript

dequeue() {
  if (this.isEmpty()) {
    throw new Error('Queue is empty');
  }
  const element = this.queue[this.front];
  this.front = (this.front [1] 1) % this.size;
  this.count [2] 1;
  return element;
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong operators like multiplication or division for pointer or count updates.

Front moves forward by adding 1 modulo size, and count decreases by 1 after dequeue.

5fill in blank

hard

Fill both blanks to implement the isEmpty method correctly and initialize rear pointer.

DSA Javascript

isEmpty() {
  return this.count [1] 0;
}

constructor(size) {
  this.size = size;
  this.queue = new Array(size);
  this.front = 0;
  this.rear = [2];
  this.count = 0;
}

Drag options to blanks, or click blank then click option'

A===

B-1

C!==

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison operators or initializing rear to 0 which conflicts with empty state.

Queue is empty when count equals 0. Rear pointer initializes to -1. Front pointer initializes to 0.

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