Enqueue Operation in DSA Typescript

Mental Model

Add a new item to the end of a line so it waits its turn.

Analogy: Imagine people standing in a queue at a ticket counter. When a new person arrives, they join at the back of the line.

front -> 1 -> 2 -> 3 -> null
                 ↑rear

Dry Run Walkthrough

Input: queue: 1 -> 2 -> 3 -> null, enqueue value 4

Goal: Add the value 4 to the end of the queue

Step 1: Create a new node with value 4

newNode(4) -> null

Why: We need a new node to add to the queue

Step 2: Link current rear node (3) to new node (4)

1 -> 2 -> 3 -> [rear->4] -> null

Why: Attach new node at the end of the queue

Step 3: Update rear pointer to new node (4)

front -> 1 -> 2 -> 3 -> 4 -> null
                      ↑rear

Why: Rear must always point to the last node

Result:

front -> 1 -> 2 -> 3 -> 4 -> null
                      ↑rear

Annotated Code

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class Queue {
  front: Node | null;
  rear: Node | null;

  constructor() {
    this.front = null;
    this.rear = null;
  }

  enqueue(value: number): void {
    const newNode = new Node(value); // create new node
    if (this.rear === null) { // empty queue
      this.front = newNode; // front and rear both point to new node
      this.rear = newNode;
    } else {
      this.rear.next = newNode; // link new node at end
      this.rear = newNode; // update rear pointer
    }
  }

  printQueue(): void {
    let curr = this.front;
    let result = '';
    while (curr !== null) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.enqueue(4);
queue.printQueue();

const newNode = new Node(value); // create new node

create a new node with the given value

if (this.rear === null) { // empty queue

check if queue is empty to initialize front and rear

this.front = newNode; // front and rear both point to new node

set front pointer when queue was empty

this.rear.next = newNode; // link new node at end

link new node after current rear

this.rear = newNode; // update rear pointer

move rear pointer to new node

Output

1 -> 2 -> 3 -> 4 -> null

Complexity Analysis

Time: O(1) because we add the new node directly at the rear without traversing

Space: O(1) because only one new node is created regardless of queue size

vs Alternative: Compared to adding at front or traversing to end (O(n)), enqueue at rear is faster and constant time

Edge Cases

Empty queue

Front and rear both point to the new node

DSA Typescript

if (this.rear === null) {

Single element queue

New node is linked after the single node and rear updates

DSA Typescript

this.rear.next = newNode;

When to Use This Pattern

When you see a problem asking to add items in order and remove from front, reach for the queue enqueue pattern because it efficiently adds at the rear.

Common Mistakes

Mistake: Not updating the rear pointer after adding the new node
Fix: Always set rear = newNode after linking it

Mistake: Not handling empty queue case causing null pointer errors
Fix: Check if rear is null and set front and rear to newNode

Summary

Adds a new element at the end of the queue.

Use when you want to maintain order and add items to the back.

Remember to update the rear pointer and handle empty queue separately.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Adds an element to the end of the queue

B. Removes an element from the front of the queue

C. Checks if the queue is empty

D. Returns the size of the queue

Solution

1. Step 1: Understand the queue structure

   A queue works like a line where elements are added at the back and removed from the front.

2. Step 2: Define the enqueue operation

   Enqueue means adding a new element to the end of the queue, so it waits its turn.

3. Final Answer:

   Adds an element to the end of the queue -> Option A

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue means add at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue (removal)
• Thinking enqueue checks queue size
• Assuming enqueue removes elements

2. Which of the following is the correct TypeScript syntax to add an element 5 to a queue represented by an array queue?

easy

A. queue.pop(5);

B. queue.push(5);

C. queue.shift(5);

D. queue.unshift(5);

Solution

1. Step 1: Identify array methods for queue operations

   In TypeScript, push adds an element at the end, which matches enqueue.

2. Step 2: Match enqueue with correct method

   pop removes from end, shift removes from front, unshift adds at front. So only push adds at the end.

3. Final Answer:

   queue.push(5); -> Option B

4. Quick Check:

   Enqueue uses push() to add at end [OK]

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

Common Mistakes:

• Using pop() which removes instead of adds
• Using shift() or unshift() which affect front of queue
• Confusing push() with unshift()

3. What will be the state of the queue after executing the following TypeScript code?

let queue: number[] = [10, 20, 30];
queue.push(40);
queue.push(50);

medium

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

B. [50, 40, 10, 20, 30]

C. [10, 20, 30]

D. [40, 50]

Solution

1. Step 1: Start with initial queue

   The queue starts as [10, 20, 30].

2. Step 2: Apply enqueue operations

   First, push(40) adds 40 at the end: [10, 20, 30, 40]. Then push(50) adds 50 at the end: [10, 20, 30, 40, 50].

3. Final Answer:

   [10, 20, 30, 40, 50] -> Option A

4. Quick Check:

   push adds at end, final queue = [10,20,30,40,50] [OK]

Hint: push() adds elements at the end in order [OK]

Common Mistakes:

• Thinking push adds at front
• Ignoring second push operation
• Confusing push with pop or shift

4. Identify the error in the following TypeScript code that tries to enqueue an element 25 to a queue represented by an array queue:

let queue: number[] = [5, 10, 15];
queue.pop(25);

medium

A. The element 25 should be added using shift

B. pop adds element at the front, so wrong method

C. The queue array is not initialized properly

D. pop does not take arguments and removes from the end

Solution

1. Step 1: Understand pop() method behavior

   pop() removes the last element from the array and does not accept any arguments.

2. Step 2: Identify misuse of pop()

   Calling pop(25) is incorrect because pop() cannot add elements; it only removes.

3. Final Answer:

   pop does not take arguments and removes from the end -> Option D

4. Quick Check:

   pop() removes, push() adds [OK]

Hint: pop() removes last element; push() adds at end [OK]

Common Mistakes:

• Using pop() to add elements
• Confusing shift() and pop()
• Passing arguments to pop()

5. You have a queue implemented as an array in TypeScript. You want to enqueue multiple elements [100, 200, 300] at once while preserving order. Which code snippet correctly enqueues all elements in order?

hard

A. queue.unshift(100, 200, 300);

B. queue.push([100, 200, 300]);

C. queue.push(100, 200, 300);

D. queue.pop(100); queue.pop(200); queue.pop(300);

Solution

1. Step 1: Understand push with multiple arguments

   push() can take multiple arguments and adds them in order at the end of the array.

2. Step 2: Analyze each option

   queue.push(100, 200, 300); adds 100, 200, 300 in order at the end. queue.push([100, 200, 300]); adds a single array element, nesting the array. queue.unshift(100, 200, 300); adds elements at the front, reversing order. queue.pop(100); queue.pop(200); queue.pop(300); uses pop which removes elements, not adds.

3. Final Answer:

   queue.push(100, 200, 300); -> Option C

4. Quick Check:

   push(...items) adds all at end in order [OK]

Hint: Use push with multiple args to enqueue many elements [OK]

Common Mistakes:

• Using push with array argument nests array
• Using unshift adds at front, reversing order
• Using pop to add elements