Insert at End Tail Insert in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Javascript

function Node(value) {
  this.data = value;
  this.next = [1];
}

Drag options to blanks, or click blank then click option'

Anull

B0

Cundefined

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to undefined instead of null.

Setting next to 0 or false which are not valid pointers.

When creating a new node, its next pointer should be null because it does not point to any node yet.

2fill in blank

medium

Complete the code to check if the linked list is empty before inserting.

DSA Javascript

function insertAtEnd(head, value) {
  let newNode = new Node(value);
  if (head [1] null) {
    return newNode;
  }
  // rest of code omitted
}

Drag options to blanks, or click blank then click option'

A===

B!==

C>=

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using !== which checks for not equal.

Using > or < which are not suitable for null checks.

To check if the list is empty, we compare head to null using strict equality ===.

3fill in blank

hard

Fix the error in the loop that finds the last node.

DSA Javascript

let current = head;
while (current.next [1] null) {
  current = current.next;
}

Drag options to blanks, or click blank then click option'

A==

B===

C!==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using === which stops immediately.

Using == or != which are less strict and can cause bugs.

The loop should continue while current.next is not null, so use !== for strict inequality.

4fill in blank

hard

Fill both blanks to correctly insert the new node at the end.

DSA Javascript

let current = head;
while (current.next [1] null) {
  current = current.next;
}
current.next = [2];

Drag options to blanks, or click blank then click option'

A!==

B===

CnewNode

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using === in the loop condition which stops too early.

Setting current.next to null instead of the new node.

The loop continues while current.next is not null, then sets current.next to the new node to insert at the end.

5fill in blank

hard

Fill all three blanks to complete the insertAtEnd function.

DSA Javascript

function insertAtEnd(head, value) {
  let newNode = new Node([1]);
  if (head [2] null) {
    return newNode;
  }
  let current = head;
  while (current.next [3] null) {
    current = current.next;
  }
  current.next = newNode;
  return head;
}

Drag options to blanks, or click blank then click option'

Avalue

B===

C!==

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined or null instead of value when creating new node.

Using != or !== incorrectly in conditions.

Not returning head after insertion.

We create a new node with the given value, check if head is null using ===, and loop while current.next !== null to find the last node.

Practice

1. What does the "Insert at End (Tail Insert)" operation do in a linked list?

easy

A. Adds a new node at the end of the linked list

B. Removes the first node from the linked list

C. Adds a new node at the beginning of the linked list

D. Deletes the last node from the linked list

Solution

1. Step 1: Understand the operation

   Insert at End means adding a new node after the last node in the linked list.

2. Step 2: Compare with other operations

   Other options describe removing or adding at the start, which is different from tail insert.

3. Final Answer:

   Adds a new node at the end of the linked list -> Option A

4. Quick Check:

   Insert at End = Add node at tail [OK]

Hint: Tail insert always adds node after the last node [OK]

Common Mistakes:

• Confusing tail insert with head insert
• Thinking it removes nodes instead of adding
• Assuming it inserts in the middle

2. Which of the following is the correct syntax to create a new node and insert it at the end of a singly linked list in JavaScript?

easy

A. let newNode = { data: value }; newNode.next = head;

B. let newNode = { data: value, next: null }; tail.next = newNode; tail = newNode;

C. let newNode = new Node(value); newNode.next = head; head = newNode;

D. let newNode = { value: data, nextNode: null }; head.next = newNode;

Solution

1. Step 1: Identify correct node creation

   Node should have data and next properties; next set to null for tail.

2. Step 2: Insert at end

   Set current tail's next to newNode, then update tail to newNode.

3. Final Answer:

   let newNode = { data: value, next: null }; tail.next = newNode; tail = newNode; -> Option B

4. Quick Check:

   Correct node creation and tail update [OK]

Hint: Tail insert needs next=null and tail pointer update [OK]

Common Mistakes:

• Using wrong property names like nextNode
• Inserting at head instead of tail
• Not updating tail pointer

3. What will be the output linked list after executing the following code?

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

class LinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  insertAtEnd(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }
}

const list = new LinkedList();
list.insertAtEnd(5);
list.insertAtEnd(10);
list.insertAtEnd(15);

let current = list.head;
let result = '';
while(current) {
  result += current.data + ' -> ';
  current = current.next;
}
result += 'null';
console.log(result);

medium

A. 5 -> 10 -> 15 -> null

B. 15 -> 10 -> 5 -> null

C. 5 -> 10 -> null

D. null

Solution

1. Step 1: Insert nodes at end

   Nodes 5, 10, 15 are inserted sequentially at the tail.

2. Step 2: Traverse and print list

   Traversal prints nodes in insertion order: 5 -> 10 -> 15 -> null.

3. Final Answer:

   5 -> 10 -> 15 -> null -> Option A

4. Quick Check:

   Tail insert preserves order [OK]

Hint: Tail insert keeps order; print from head to tail [OK]

Common Mistakes:

• Confusing head and tail order
• Missing last node in output
• Printing reversed list

4. Find the error in the following tail insert method and select the correct fix:

insertAtEnd(data) {
  const newNode = new Node(data);
  if (this.head === null) {
    this.head = newNode;
  } else {
    this.tail.next = newNode;
  }
  // Missing update of tail pointer
}

medium

A. Change 'this.head = newNode;' to 'this.tail = newNode;' in if block

B. Set 'newNode.next = this.tail;' before insertion

C. Remove the else block completely

D. Add 'this.tail = newNode;' after setting tail.next

Solution

1. Step 1: Identify missing tail update

   After inserting newNode at tail.next, tail pointer must update to newNode.

2. Step 2: Fix by adding tail update

   Add 'this.tail = newNode;' after 'this.tail.next = newNode;' to keep tail correct.

3. Final Answer:

   Add 'this.tail = newNode;' after setting tail.next -> Option D

4. Quick Check:

   Tail pointer must update after insertion [OK]

Hint: Always update tail pointer after inserting at end [OK]

Common Mistakes:

• Not updating tail pointer causes broken list
• Changing head instead of tail in else block
• Incorrectly setting newNode.next to tail

5. You have a singly linked list with nodes: 1 -> 2 -> 3 -> null and a tail pointer correctly pointing to node 3. You want to insert a new node with value 4 at the end. Which sequence of operations correctly updates the list and tail pointer?

hard

A. Create newNode(4), newNode.next = tail, tail = newNode

B. Create newNode(4), head.next = newNode, tail = newNode

C. Create newNode(4), tail.next = newNode, tail = newNode

D. Create newNode(4), tail = newNode, tail.next = null

Solution

1. Step 1: Create new node with value 4

   Initialize newNode with data=4 and next=null.

2. Step 2: Link newNode after current tail and update tail

   Set tail.next = newNode to link, then update tail = newNode to move tail pointer.

3. Final Answer:

   Create newNode(4), tail.next = newNode, tail = newNode -> Option C

4. Quick Check:

   Tail insert requires linking and tail update [OK]

Hint: Link new node after tail, then update tail pointer [OK]

Common Mistakes:

• Linking new node to head instead of tail
• Setting newNode.next to tail (wrong direction)
• Updating tail before linking new node