Circular Queue Implementation Using Array in DSA Typescript - Build from Scratch

Circular Queue Implementation Using Array

📖 Scenario: Imagine you are managing a small parking lot with a fixed number of parking spots arranged in a circle. Cars enter and leave in order, and when the lot is full, new cars must wait until a spot frees up. We will simulate this using a circular queue implemented with an array.

🎯 Goal: You will build a circular queue using an array in TypeScript. You will create the queue array, set up pointers to track the front and rear positions, add elements to the queue, remove elements from the queue, and finally print the current state of the queue.

📋 What You'll Learn

Create an array called queue with size 5 initialized with -1 to represent empty spots

Create two variables called front and rear initialized to -1

Write a function called enqueue that adds an element to the queue if there is space

Write a function called dequeue that removes an element from the queue if it is not empty

Print the current state of the queue array after performing enqueue and dequeue operations

💡 Why This Matters

🌍 Real World

Circular queues are used in real-world systems like traffic lights, CPU scheduling, and buffering data streams where resources are reused in a cycle.

💼 Career

Understanding circular queues helps in roles involving system design, embedded programming, and performance optimization where fixed-size buffers are common.

1

Create the queue array and pointers

Create an array called queue of size 5 initialized with -1 to represent empty spots. Also create two variables called front and rear and set both to -1.

DSA Typescript

const queue: number[] = [-1, -1, -1, -1, -1];
let front = -1;
let rear = -1;
// Your code here

Hint

Use const queue: number[] = [-1, -1, -1, -1, -1] to create the array. Use let front = -1 and let rear = -1 to create the pointers.

2

Create the enqueue function

Create a function called enqueue that takes a number value as input. Inside the function, check if the queue is full by seeing if (rear + 1) % 5 === front. If full, do nothing. Otherwise, if front is -1, set it to 0. Then update rear to (rear + 1) % 5 and set queue[rear] to value.

DSA Typescript

const queue: number[] = [-1, -1, -1, -1, -1];
let front = -1;
let rear = -1;

function enqueue(value: number): void {
    // Your code here
}

Hint

Remember to check if the queue is full first. Use modulo % to wrap around the array. Update front if it was -1.

3

Create the dequeue function

Create a function called dequeue that removes and returns the front element from the queue. If front is -1, return -1 to indicate the queue is empty. Otherwise, store queue[front] in a variable called removed. Set queue[front] to -1. If front equals rear, set both to -1. Else, update front to (front + 1) % 5. Finally, return removed.

DSA Typescript

const queue: number[] = [-1, -1, -1, -1, -1];
let front = -1;
let rear = -1;

function enqueue(value: number): void {
    if ((rear + 1) % 5 === front) {
        return;
    }
    if (front === -1) {
        front = 0;
    }
    rear = (rear + 1) % 5;
    queue[rear] = value;
}

function dequeue(): number {
    // Your code here
}

Hint

Check if the queue is empty first. Remove the front element and update pointers carefully. Return the removed element.

4

Test the queue and print the result

Call enqueue with values 10, 20, 30, 40, and 50 in this order. Then call dequeue twice. Then call enqueue with 60 and 70. Finally, print the queue array, front, and rear variables using console.log.

DSA Typescript

const queue: number[] = [-1, -1, -1, -1, -1];
let front = -1;
let rear = -1;

function enqueue(value: number): void {
    if ((rear + 1) % 5 === front) {
        return;
    }
    if (front === -1) {
        front = 0;
    }
    rear = (rear + 1) % 5;
    queue[rear] = value;
}

function dequeue(): number {
    if (front === -1) {
        return -1;
    }
    const removed = queue[front];
    queue[front] = -1;
    if (front === rear) {
        front = -1;
        rear = -1;
    } else {
        front = (front + 1) % 5;
    }
    return removed;
}

// Your code here

Hint

Follow the instructions step by step. Remember the queue size is 5 and uses circular indexing.

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