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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue and dequeue operations?

Consider a queue implemented using an array with a fixed size of 5. Initially, the queue is empty. We perform the following operations in order:
enqueue(10), enqueue(20), enqueue(30), dequeue(), enqueue(40), dequeue(), enqueue(50).
What is the state of the queue after these operations?

DSA Typescript

class Queue {
  private items: number[] = [];
  private maxSize: number;

  constructor(size: number) {
    this.maxSize = size;
  }

  enqueue(element: number): boolean {
    if (this.items.length === this.maxSize) return false;
    this.items.push(element);
    return true;
  }

  dequeue(): number | null {
    if (this.items.length === 0) return null;
    return this.items.shift()!;
  }

  getQueue(): number[] {
    return this.items;
  }
}

const q = new Queue(5);
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.dequeue();
q.enqueue(40);
q.dequeue();
q.enqueue(50);
console.log(q.getQueue());

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

B [20, 30, 40, 50]

C [30, 40, 50]

D [40, 50]

💡 Hint

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

After enqueue(10), enqueue(20), enqueue(30), the queue is [10, 20, 30]. dequeue() removes 10, queue becomes [20, 30]. enqueue(40) adds 40: [20, 30, 40]. dequeue() removes 20: [30, 40]. enqueue(50) adds 50: [30, 40, 50].

🧠 Conceptual

intermediate

What happens when enqueue is called on a full queue?

In a queue implemented using a fixed-size array, what is the expected behavior when you try to enqueue an element but the queue is already full?

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

B The enqueue operation fails and returns false or an error indicating the queue is full.

C The queue size automatically doubles to accommodate the new element.

D The new element overwrites the last element in the queue.

💡 Hint

Think about fixed size and how arrays behave when full.

In a fixed-size array queue, when full, enqueue cannot add new elements. It should fail gracefully, often returning false or throwing an error.

🔧 Debug

advanced

Identify the bug in this dequeue method

The following dequeue method is part of a queue implemented using an array. It is supposed to remove and return the front element. What is the bug in this code?

DSA Typescript

dequeue(): number | null {
  if (this.items.length === 0) return null;
  return this.items.pop();
}

A It removes the last element instead of the first, so it does not behave like a queue.

B It throws an error when the queue is empty instead of returning null.

C It removes the first element but does not return it.

D It removes the first element but does not update the queue size.

💡 Hint

Remember that queues remove from the front, not the back.

pop() removes the last element of the array, but dequeue should remove the first element. The correct method is shift().

📝 Syntax

advanced

Which option correctly implements enqueue with capacity check?

Choose the correct enqueue method implementation that adds an element to the queue only if there is space left in the fixed-size array.

A

enqueue(element: number): boolean {
  if (this.items.length < this.maxSize) {
    this.items.unshift(element);
    return true;
  }
  return false;
}

B

enqueue(element: number): boolean {
  if (this.items.length > this.maxSize) return false;
  this.items.push(element);
  return true;
}

C

enqueue(element: number): boolean {
  if (this.items.length === this.maxSize) {
    this.items.push(element);
    return true;
  }
  return false;
}

D

enqueue(element: number): boolean {
  if (this.items.length >= this.maxSize) return false;
  this.items.push(element);
  return true;
}

💡 Hint

Check the condition and method used to add element at the end.

Option D correctly checks if length is >= maxSize to prevent overflow, then pushes element at the end and returns true. Others either have wrong condition or use unshift which adds at front.

🚀 Application

expert

How many items remain after circular queue operations?

A circular queue is implemented using an array of size 4. Initially empty, the following operations are performed:
enqueue(1), enqueue(2), enqueue(3), dequeue(), enqueue(4), enqueue(5), dequeue(), enqueue(6).
How many items are currently in the queue?

A 4

B 5

C 2

D 3

💡 Hint

Remember circular queue wraps around and max size is 4.

Operations:
enqueue(1) -> size 1
enqueue(2) -> size 2
enqueue(3) -> size 3
dequeue() removes 1 -> size 2
enqueue(4) -> size 3
enqueue(5) -> size 4 (full)
dequeue() removes 2 -> size 3
enqueue(6) -> size 4 (full)
So final size is 4, but since max size is 4, after last enqueue size is 4.
But the question asks how many items currently in the queue after all operations, which is 4.

Practice

1. What is the main characteristic of a queue data structure implemented using an array?

easy

A. It stores elements in sorted order automatically

B. It follows Last-In-First-Out (LIFO) order

C. It allows random access to elements

D. It follows First-In-First-Out (FIFO) order

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the rear and removes from the front, so the first element added is the first removed.

2. Step 2: Compare with options

   FIFO means First-In-First-Out, which matches queue behavior. LIFO is for stacks, random access is for arrays, and sorting is unrelated.

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option D

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue always removes the oldest element first [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements automatically

2. Which of the following is the correct way to add an element `x` to the rear of a queue implemented as an array named `queue` in TypeScript?

easy

A. queue.unshift(x);

B. queue.push(x);

C. queue.shift(x);

D. queue.pop(x);

Solution

1. Step 1: Identify array methods for queue operations

   To add at the rear of the queue, we use the array method that appends elements at the end, which is push().

2. Step 2: Check each option

   push(x) adds x at the end; pop() removes from end; shift() removes from front; unshift() adds at front.

3. Final Answer:

   queue.push(x); -> Option B

4. Quick Check:

   Enqueue = push() [OK]

Hint: Use push() to add at the end of array [OK]

Common Mistakes:

• Using pop() which removes instead of adds
• Using shift() or unshift() incorrectly for enqueue
• Confusing push() with unshift()

3. What will be the output of the following TypeScript code implementing a queue using an array?

const queue: number[] = [];
queue.push(10);
queue.push(20);
const removed = queue.shift();
queue.push(30);
console.log(queue);

medium

A. [20, 30]

B. [10, 20, 30]

C. [30, 20]

D. [10, 30]

Solution

1. Step 1: Trace queue operations step-by-step

   Initially queue = []. After push(10), queue = [10]. After push(20), queue = [10, 20]. shift() removes first element 10, queue = [20]. Then push(30), queue = [20, 30].

2. Step 2: Determine final queue state

   After all operations, queue contains [20, 30].

3. Final Answer:

   [20, 30] -> Option A

4. Quick Check:

   After shift(), first element removed, queue = [20, 30] [OK]

Hint: shift() removes front, push() adds rear [OK]

Common Mistakes:

• Forgetting shift() removes first element
• Assuming push() adds at front
• Confusing order of elements after operations

4. Identify the error in the following TypeScript code for queue implementation using an array:

const queue: number[] = [];
queue.push(1);
queue.push(2);
const removed = queue.pop();
console.log(queue);

medium

A. push() should be replaced with unshift()

B. queue should be declared as a linked list

C. Using pop() removes from rear, not front

D. No error, code works correctly

Solution

1. Step 1: Understand queue removal operation

   Queue removes elements from the front (FIFO). Using pop() removes from the rear (last element), which breaks FIFO.

2. Step 2: Check code behavior

   pop() removes last element (2), but queue should remove first element (1) using shift().

3. Final Answer:

   Using pop() removes from rear, not front -> Option C

4. Quick Check:

   Dequeue = shift(), not pop() [OK]

Hint: Use shift() to remove front element, not pop() [OK]

Common Mistakes:

• Using pop() instead of shift() for dequeue
• Thinking push() adds at front
• Confusing array methods for queue operations

5. You want to implement a queue using a fixed-size array of length 3 in TypeScript. After enqueueing 3 elements, you dequeue one element and then enqueue another. What problem will you face if you do not use a circular queue approach?

hard

A. You cannot enqueue the new element because the rear index reached the array end

B. The queue will automatically resize to fit new elements

C. Dequeue operation will remove the wrong element

D. The queue will lose all previous elements

Solution

1. Step 1: Understand fixed-size array queue behavior

   With a fixed-size array, rear index moves forward on enqueue. After 3 enqueues, rear is at end.

2. Step 2: Analyze enqueue after dequeue without circular logic

   Dequeue moves front forward but rear stays at end. Without circular wrap, rear cannot move back to start, so enqueue fails.

3. Final Answer:

   You cannot enqueue the new element because the rear index reached the array end -> Option A

4. Quick Check:

   Fixed array + no circular = enqueue blocked at end [OK]

Hint: Fixed array needs circular logic to reuse space [OK]

Common Mistakes:

• Assuming array resizes automatically
• Thinking dequeue affects rear index
• Ignoring circular queue necessity