Enqueue Operation in DSA Typescript - Execution Trace

Concept Flow - Enqueue Operation

Create new node with value

↓

Is queue empty?

Yes→Set head and tail to new node

|No↓

Set tail.next to new node

↓

Update tail to new node

↓

Done

This flow shows how a new node is added at the end of the queue by updating pointers.

Execution Sample

DSA Typescript

class Node {
  constructor(public value: number, public next: Node | null = null) {}
}

class Queue {
  head: Node | null = null;
  tail: Node | null = null;

  enqueue(value: number) {
    const newNode = new Node(value);
    if (!this.tail) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }
}

This code adds a new value to the end of the queue, updating head and tail pointers accordingly.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Enqueue 10 on empty queue	10	head -> 10, tail -> 10	10 -> null
2	Enqueue 20	10 -> 20	tail.next -> 20, tail -> 20	10 -> 20 -> null
3	Enqueue 30	10 -> 20 -> 30	tail.next -> 30, tail -> 30	10 -> 20 -> 30 -> null
4	Stop	No more enqueue operations	No pointer changes	10 -> 20 -> 30 -> null

💡 No more values to enqueue, operation ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
head	null	Node(10)	Node(10)	Node(10)	Node(10)
tail	null	Node(10)	Node(20)	Node(30)	Node(30)
queue size	0	1	2	3	3

Key Moments - 3 Insights

Why do we check if the queue is empty before adding a new node?

Because if the queue is empty, both head and tail must point to the new node. This is shown in step 1 of the execution_table where head and tail are set to the new node.

Why do we update tail.next before moving tail to the new node?

Updating tail.next links the old last node to the new node, maintaining the chain. Then tail moves to the new node to mark the new end. This is shown in steps 2 and 3 where tail.next changes before tail pointer updates.

What happens if we forget to update the tail pointer?

The tail pointer would still point to the old last node, breaking the queue's end. New nodes would not be added correctly. The execution_table shows tail moving to the new node each time to avoid this.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what does tail point to after enqueueing 20?

A Node with value 10

B Node with value 20

C Node with value 30

D null

💡 Hint

Check the 'Pointer Changes' column at step 2 in execution_table.

At which step does the queue first have more than one node?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Nodes in List' column in execution_table to see when nodes count increases.

If the queue was not empty, which pointer is updated first during enqueue?

A tail.next

B head

C tail

D head.next

💡 Hint

Refer to the 'Pointer Changes' column in steps 2 and 3 of execution_table.

Concept Snapshot

Enqueue Operation in Queue:
- Create new node with value
- If queue empty: head and tail point to new node
- Else: tail.next points to new node
- Update tail to new node
- Maintains FIFO order
- Visual: 10 -> 20 -> 30 -> null

Full Transcript

The enqueue operation adds a new element at the end of the queue. First, a new node is created with the given value. If the queue is empty, both head and tail pointers are set to this new node. Otherwise, the current tail's next pointer is set to the new node, and then the tail pointer itself is updated to the new node. This keeps the queue in order, with new elements added at the end. The execution table shows step-by-step how nodes and pointers change as values 10, 20, and 30 are enqueued. The variable tracker follows head, tail, and queue size changes. Key moments clarify why checking for empty queue and updating pointers in order is important. The visual quiz tests understanding of pointer updates and queue state during enqueue.

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