Enqueue Using Linked List in DSA Javascript

Mental Model

Add a new item at the end of a line so everyone stays in order. We keep track of the last person to add new ones quickly.

Analogy: Imagine a queue at a ticket counter. New people join at the end, and the counter serves from the front. We remember the last person in line to add new arrivals fast.

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

Dry Run Walkthrough

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

Goal: Add value 4 at the end of the queue so it becomes 1 -> 2 -> 3 -> 4 -> null

Step 1: Create 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 to keep order

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

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

Why: Rear must point to the last node for next enqueue

Result:

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

Annotated Code

DSA Javascript

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

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

  enqueue(value) {
    const newNode = new Node(value); // create new node
    if (this.rear === null) { // if queue empty
      this.front = newNode; // front and rear both point to new node
      this.rear = newNode;
      return;
    }
    this.rear.next = newNode; // link last node to new node
    this.rear = newNode; // update rear to new node
  }

  printQueue() {
    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.printQueue();
queue.enqueue(4);
queue.printQueue();

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

create a new node to add at the end

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

check if queue is empty to set front and rear

this.rear.next = newNode; // link last node to new node

attach new node after current rear

this.rear = newNode; // update rear to new node

move rear pointer to new last node

Output

1 -> 2 -> 3 -> null

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

Complexity Analysis

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

Space: O(1) because we only create one new node for each enqueue operation

vs Alternative: Compared to adding at the front or traversing the list to add at the end (O(n)), this method is faster because we keep a rear pointer

Edge Cases

empty queue

front and rear both point to the new node

DSA Javascript

if (this.rear === null) {

single element queue

new node is linked after the single node and rear updates

DSA Javascript

this.rear.next = newNode;

When to Use This Pattern

When you need to add items in order at the end of a line and want fast insertion, use enqueue with a rear pointer in a linked list.

Common Mistakes

Mistake: Not updating the rear pointer after adding the new node
Fix: Always set rear = newNode after linking to keep track of the last node

Mistake: Not handling empty queue case where front and rear are null
Fix: Check if rear is null and set both front and rear to new node

Summary

Adds a new element at the end of a linked list queue efficiently.

Use when you want to maintain order and add items quickly at the end.

Keep a rear pointer to avoid traversing the whole list for each enqueue.

Practice

1. What does the enqueue operation do in a queue implemented using a linked list?

easy

A. Deletes the entire linked list

B. Removes an element from the front (head) of the linked list

C. Adds a new element at the end (tail) of the linked list

D. Adds a new element at the front (head) of the linked list

Solution

1. Step 1: Understand enqueue operation

   Enqueue means adding an element to the queue.

2. Step 2: Identify position in linked list

   In a linked list queue, new elements are added at the tail (end).

3. Final Answer:

   Adds a new element at the end (tail) of the linked list -> Option C

4. Quick Check:

   Enqueue = add at tail [OK]

Hint: Enqueue always adds at the tail in linked list queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Adding new element at the head instead of tail
• Thinking enqueue removes elements

2. Which of the following is the correct way to create a new node for enqueue in JavaScript linked list?

easy

A. const node = { value: val, next: null };

B. const node = new Node(val); node.next = val;

C. const node = { val: value, next: undefined };

D. const node = Node(val, null);

Solution

1. Step 1: Understand node structure

   A node should have a value and a pointer to next (null initially).

2. Step 2: Check syntax correctness

   const node = { value: val, next: null }; correctly creates an object with value and next set to null.

3. Final Answer:

   const node = { value: val, next: null }; -> Option A

4. Quick Check:

   Node = {{value, next:null}} [OK]

Hint: Node must have value and next=null for enqueue [OK]

Common Mistakes:

• Using wrong property names like 'val' instead of 'value'
• Setting next to undefined instead of null
• Calling Node as a function without new keyword

3. What will be the state of the queue after these operations?

enqueue(10); enqueue(20); enqueue(30);

Assuming an empty queue initially, what is the linked list representation?

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. null -> 10 -> 20 -> 30

D. 20 -> 10 -> 30 -> null

Solution

1. Step 1: Enqueue 10

   Queue is empty, so 10 becomes head and tail: 10 -> null

2. Step 2: Enqueue 20 and 30

   20 added at tail: 10 -> 20 -> null, then 30 added: 10 -> 20 -> 30 -> null

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Order preserved, enqueue adds at tail [OK]

Hint: Enqueue adds at tail, order stays same [OK]

Common Mistakes:

• Reversing order of elements
• Confusing head and tail positions
• Assuming enqueue adds at head

4. Consider this enqueue function snippet:

function enqueue(val) {
  const node = { value: val, next: null };
  if (!this.tail) {
    this.head = node;
  }
  this.tail.next = node;
  this.tail = node;
}

What error will occur when enqueue is called on an empty queue?

medium

A. ReferenceError: this is not defined

B. SyntaxError: Unexpected token

C. No error, works fine

D. TypeError: Cannot read property 'next' of null

Solution

1. Step 1: Analyze empty queue condition

   When queue is empty, this.tail is null or undefined.

2. Step 2: Identify error line

   Code tries this.tail.next = node; but this.tail is null, causing TypeError.

3. Final Answer:

   TypeError: Cannot read property 'next' of null -> Option D

4. Quick Check:

   Accessing next on null causes TypeError [OK]

Hint: Check if tail exists before accessing next [OK]

Common Mistakes:

• Ignoring null check for tail
• Assuming no error on empty queue
• Confusing this.head and this.tail usage

5. You want to implement enqueue in a linked list queue that keeps track of both head and tail. Which of these code snippets correctly enqueues a new value val?

hard

A. const node = { value: val, next: null };
this.tail.next = node;
this.tail = node;

B. const node = { value: val, next: null };
if (!this.head) {
this.head = node;
this.tail = node;
} else {
this.tail.next = node;
this.tail = node;
}

C. const node = { value: val, next: this.head };
this.head = node;

D. const node = { value: val, next: null };
this.head.next = node;
this.head = node;

Solution

1. Step 1: Handle empty queue case

   If head is null, both head and tail should point to new node.

2. Step 2: Handle non-empty queue

   Set tail.next to new node and update tail to new node.

3. Final Answer:

   const node = { value: val, next: null }; if (!this.head) { this.head = node; this.tail = node; } else { this.tail.next = node; this.tail = node; } -> Option B

4. Quick Check:

   Check empty and non-empty cases for enqueue [OK]

Hint: Set head and tail on empty, else add at tail.next [OK]

Common Mistakes:

• Not updating tail on empty queue
• Adding new node at head instead of tail
• Forgetting to update tail pointer