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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Queue Enqueue and Dequeue Operations

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

DSA Typescript

class CircularQueue {
  private queue: number[];
  private front: number;
  private rear: number;
  private size: number;
  private capacity: number;

  constructor(capacity: number) {
    this.capacity = capacity;
    this.queue = new Array(capacity);
    this.front = -1;
    this.rear = -1;
    this.size = 0;
  }

  enqueue(value: number): boolean {
    if (this.size === this.capacity) return false;
    if (this.size === 0) this.front = 0;
    this.rear = (this.rear + 1) % this.capacity;
    this.queue[this.rear] = value;
    this.size++;
    return true;
  }

  dequeue(): number | null {
    if (this.size === 0) return null;
    const value = this.queue[this.front];
    if (this.size === 1) {
      this.front = -1;
      this.rear = -1;
    } else {
      this.front = (this.front + 1) % this.capacity;
    }
    this.size--;
    return value;
  }

  printQueue(): string {
    if (this.size === 0) return "empty";
    let result = "";
    for (let i = 0; i < this.size; i++) {
      const index = (this.front + i) % this.capacity;
      result += this.queue[index] + (i < this.size - 1 ? " -> " : " -> null");
    }
    return result;
  }
}

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 20 -> 30 -> 40 -> 50 -> 60 -> null

B 40 -> 50 -> 60 -> 70 -> null

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

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

💡 Hint

Track front and rear indices carefully after each enqueue and dequeue.

After the operations, the queue contains elements 30, 40, 50, 60, 70 in order, starting from front index. The printQueue method shows them linked with arrows ending with null.

🧠 Conceptual

intermediate

Capacity Behavior in Circular Queue

If a circular queue has capacity 4 and currently holds 4 elements, what happens when you try to enqueue one more element?

A The enqueue operation fails because the queue is full.

B The queue automatically increases its capacity and adds the element.

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

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

💡 Hint

Think about fixed size and how circular queue manages full state.

A circular queue with fixed capacity cannot add more elements when full. Enqueue returns false or fails.

🔧 Debug

advanced

Identify the Bug in Circular Queue Dequeue Method

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

DSA Typescript

dequeue(): number {
  const value = this.queue[this.front];
  if (this.size === 1) {
    this.front = -1;
    this.rear = -1;
  } else {
    this.front = (this.front + 1) % this.capacity;
  }
  this.size--;
  return value;
}

A TypeError because this.front is -1 and accessing this.queue[-1] is invalid.

B RangeError because front index goes out of bounds.

C ReferenceError because this.queue is undefined.

D No error, returns null when queue is empty.

💡 Hint

Check what happens if dequeue is called on an empty queue.

If the queue is empty, front is -1, so accessing this.queue[-1] returns undefined, but returning undefined as number causes TypeError in strict typing or unexpected behavior.

📝 Syntax

advanced

Identify Syntax Error in Circular Queue Enqueue Method

Which option contains a syntax error in the enqueue method?

DSA Typescript

enqueue(value: number): boolean {
  if (this.size === this.capacity) return false;
  if (this.size === 0) this.front = 0;
  this.rear = (this.rear + 1) % this.capacity;
  this.queue[this.rear] = value;
  this.size++;
  return true;
}

A Assigning this.queue[this.rear] = value is invalid because queue is readonly.

B Using parentheses in (this.rear + 1) % this.capacity is invalid syntax.

C Missing semicolon after return false causes syntax error.

D Incrementing this.size++ is invalid syntax.

💡 Hint

Check missing punctuation in TypeScript statements.

In TypeScript, missing semicolon after return statement can cause syntax error in some contexts.

🚀 Application

expert

Determine Final Queue State After Complex Operations

Given a circular queue of capacity 6, after these operations, what is the printed queue state? Operations: - enqueue 5 - enqueue 10 - enqueue 15 - dequeue - enqueue 20 - enqueue 25 - dequeue - enqueue 30 - enqueue 35 - dequeue - enqueue 40 - enqueue 45 - dequeue - enqueue 50 Print the queue using the format: value -> value -> ... -> null

DSA Typescript

class CircularQueue {
  private queue: number[];
  private front: number;
  private rear: number;
  private size: number;
  private capacity: number;

  constructor(capacity: number) {
    this.capacity = capacity;
    this.queue = new Array(capacity);
    this.front = -1;
    this.rear = -1;
    this.size = 0;
  }

  enqueue(value: number): boolean {
    if (this.size === this.capacity) return false;
    if (this.size === 0) this.front = 0;
    this.rear = (this.rear + 1) % this.capacity;
    this.queue[this.rear] = value;
    this.size++;
    return true;
  }

  dequeue(): number | null {
    if (this.size === 0) return null;
    const value = this.queue[this.front];
    if (this.size === 1) {
      this.front = -1;
      this.rear = -1;
    } else {
      this.front = (this.front + 1) % this.capacity;
    }
    this.size--;
    return value;
  }

  printQueue(): string {
    if (this.size === 0) return "empty";
    let result = "";
    for (let i = 0; i < this.size; i++) {
      const index = (this.front + i) % this.capacity;
      result += this.queue[index] + (i < this.size - 1 ? " -> " : " -> null");
    }
    return result;
  }
}

const cq = new CircularQueue(6);
cq.enqueue(5);
cq.enqueue(10);
cq.enqueue(15);
cq.dequeue();
cq.enqueue(20);
cq.enqueue(25);
cq.dequeue();
cq.enqueue(30);
cq.enqueue(35);
cq.dequeue();
cq.enqueue(40);
cq.enqueue(45);
cq.dequeue();
cq.enqueue(50);
console.log(cq.printQueue());

A 25 -> 30 -> 35 -> 40 -> 45 -> 50 -> null

B 30 -> 35 -> 40 -> 45 -> 50 -> null

C 15 -> 20 -> 25 -> 30 -> 35 -> 40 -> null

D 10 -> 15 -> 20 -> 25 -> 30 -> 35 -> null

💡 Hint

Track front and rear indices carefully after each enqueue and dequeue operation.

After all operations, the queue contains 30, 35, 40, 45, 50 in order starting from front index. The printQueue method shows them linked with arrows ending with null.

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 allows storing different data types in the same queue.

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

C. It automatically sorts the elements 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 empty spaces 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 stores different 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 indices?

easy

A. if (rear === front)

B. if (front === -1)

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

D. if (rear === size - 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: Apply modulo for wrap-around

   Using modulo ensures the rear wraps to the start of the array, so the condition is (rear + 1) % size === front.

3. Final Answer:

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

4. Quick Check:

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

Hint: Full when next rear wraps to front [OK]

Common Mistakes:

• Checking rear === front means empty, not full
• Using rear === size - 1 ignores wrap-around
• Checking front === -1 is for empty queue

3. Consider a circular queue of size 5 (indices 0 to 4). Initially, front = 0 and rear = 3. After performing enqueue(10) and dequeue(), what are the new values of front and rear?

medium

A. front = 0, rear = 4

B. front = 1, rear = 3

C. front = 0, rear = 3

D. front = 1, rear = 4

Solution

1. Step 1: Perform enqueue(10)

   rear moves from 3 to (3 + 1) % 5 = 4. So rear = 4, front remains 0.

2. Step 2: Perform dequeue()

   front moves from 0 to (0 + 1) % 5 = 1. So front = 1, rear remains 4.

3. Final Answer:

   front = 1, rear = 4 -> Option D

4. Quick Check:

   Enqueue rear+1=4, Dequeue front+1=1 [OK]

Hint: Update rear on enqueue, front on dequeue with modulo [OK]

Common Mistakes:

• Not applying modulo for wrap-around
• Updating front on enqueue instead of rear
• Confusing initial and final pointer positions

4. Given the following TypeScript snippet for dequeue operation in a circular queue, identify the bug:

function dequeue() {
  if (front === -1) return null;
  const value = queue[front];
  if (front === rear) {
    front = rear = -1;
  } else {
    front = front + 1;
  }
  return value;
}

medium

A. Missing modulo operation when updating front, causing index overflow.

B. Incorrect check for empty queue; should check rear instead of front.

C. Should update rear instead of front after dequeue.

D. Returning value before updating front causes wrong output.

Solution

1. Step 1: Analyze front update in dequeue

   The code updates front as front = front + 1 without modulo, which can exceed array bounds.

2. Step 2: Correct update with modulo

   To wrap around in circular queue, front should be updated as front = (front + 1) % size.

3. Final Answer:

   Missing modulo operation when updating front, causing index overflow. -> Option A

4. Quick Check:

   Front update needs modulo [OK]

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

Common Mistakes:

• Forgetting modulo causes index errors
• Confusing front and rear updates
• Wrong empty queue condition check

5. You have a circular queue of size 4. You perform these operations in order: enqueue(5), enqueue(10), enqueue(15), dequeue(), enqueue(20), enqueue(25). What will be the final state of the queue array (index 0 to 3) and the positions of front and rear?

hard

A. Queue: [25, 10, 15, 20], front = 1, rear = 0

B. Queue: [5, 10, 15, 20], front = 1, rear = 3

C. Queue: [20, 25, 15, 10], front = 0, rear = 1

D. Queue: [10, 15, 20, 25], front = 0, rear = 3

Solution

1. Step 1: Perform enqueues and dequeue step-by-step

   Start: front = -1, rear = -1, queue size = 4 - 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, queue unchanged - enqueue(20): rear=3, queue=[5,10,15,20] - enqueue(25): rear=(3+1)%4=0, queue[0]=25, queue=[25,10,15,20]

2. Step 2: Final front and rear positions

   front=1 (pointing to 10), rear=0 (pointing to 25). Queue array is [25,10,15,20].

3. Final Answer:

   Queue: [25, 10, 15, 20], front = 1, rear = 0 -> Option A

4. Quick Check:

   Wrap rear with modulo, front moves on dequeue [OK]

Hint: Track front/rear with modulo after each operation [OK]

Common Mistakes:

• Not wrapping rear index on enqueue
• Not updating front on dequeue
• Mixing up front and rear positions