Why Queue Implementation Using Array in DSA Typescript?

The Big Idea

What if you could never lose track of who's next in line, no matter how long it gets?

The Scenario

Imagine you are waiting in line at a coffee shop. Everyone stands one after another, and the person at the front gets served first. Now, imagine if you had to remember who came first without any order, just by guessing or writing names on random papers. It would be confusing and slow.

The Problem

Trying to manage this line manually, like using a simple list without rules, means you might serve people out of order or lose track of who is next. It becomes slow and error-prone, especially when many people join or leave the line.

The Solution

A queue implemented using an array keeps the order perfectly. It adds new people at the end and serves from the front, just like the coffee shop line. This way, everyone is served fairly and quickly without confusion.

Before vs After

✗ Before

let line = [];
line.push('Alice');
line.push('Bob');
// No clear way to remove the first person
line.splice(0, 1); // manual removal

✓ After

class Queue {
  private items: string[] = [];
  enqueue(person: string) { this.items.push(person); }
  dequeue() { return this.items.shift(); }
}

What It Enables

It enables managing ordered tasks or people efficiently, ensuring fairness and speed in processing.

Real Life Example

Queues are used in printers where documents wait their turn, or in call centers where callers are answered in the order they called.

Key Takeaways

Manual tracking of order is confusing and slow.

Queue using array keeps order and processes fairly.

It is simple and efficient for many real-world waiting scenarios.

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