Enqueue Using Linked List in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'enqueue' mean in the context of a queue data structure?

Enqueue means adding an element to the end (rear) of the queue.

beginner

Why is a linked list a good choice to implement a queue?

Because linked lists allow easy addition at the end without shifting elements, making enqueue operations efficient.

intermediate

In enqueue using linked list, which pointer is updated to add a new node?

The 'rear' pointer is updated to point to the new node added at the end.

intermediate

What happens if the queue is empty when we enqueue the first element using a linked list?

Both 'front' and 'rear' pointers are set to the new node because it is the only element.

beginner

Show the state of the queue after enqueueing 10, 20, 30 using linked list.

10 -> 20 -> 30 -> null

What pointer do we move when we enqueue a new node in a linked list queue?

A head

B front

C tail

D rear

The 'rear' pointer always points to the last node where new nodes are added.

When the queue is empty, what should both 'front' and 'rear' point to after enqueue?

A new node

B null

C previous node

D first node's next

Both 'front' and 'rear' point to the new node because it is the only element.

What is the time complexity of enqueue operation using linked list?

A O(log n)

B O(n)

C O(1)

D O(n^2)

Enqueue is O(1) because we add the new node directly at the rear without traversal.

Which of these is NOT true about enqueue using linked list?

A We add new node at the rear

B We shift all nodes to add new element

C If empty, front and rear point to new node

D We update rear pointer to new node

We do NOT shift nodes; linked list allows direct addition at the end.

After enqueueing elements 5 and 15, what is the correct queue order?

A 5 -> 15 -> null

B 15 -> 5 -> null

C null -> 5 -> 15

D 15 -> null -> 5

Elements are added at the rear, so order is 5 then 15.

Explain step-by-step how to enqueue an element in a queue implemented with a linked list.

Think about pointers front and rear and how they change.

Draw or describe the linked list queue after enqueueing 1, 2, and 3 in order.

Visualize nodes connected with arrows.

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