Delete Node at End in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to move to the last node in the linked list.

DSA Javascript

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 '==' instead of '!==' causes the loop to stop immediately.

Using '=' causes assignment instead of comparison.

We use '!== null' to continue moving until the last node whose next is null.

2fill in blank

medium

Complete the code to delete the last node by setting the second last node's next to null.

DSA Javascript

secondLast.next [1] null;

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

A==

B!==

C=

D=>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '=' causes a comparison, not assignment.

Using '=>' is invalid syntax here.

We assign null to secondLast.next to remove the last node.

3fill in blank

hard

Fix the error in the loop condition to find the second last node.

DSA Javascript

while (current.next.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 '==' causes the loop to stop too early.

Using '=' causes assignment error.

We check that current.next.next is not null to stop at second last node.

4fill in blank

hard

Fill both blanks to correctly find the second last node and delete the last node.

DSA Javascript

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

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

A!==

B==

D===

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' in either condition causes errors or wrong node deletion.

Using '===' is too strict and may cause unexpected behavior.

Both conditions check for not equal to null to find second last node safely.

5fill in blank

hard

Fill all three blanks to delete the last node from a singly linked list safely.

DSA Javascript

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

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

A!==

B==

C=

D===

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '!==' causes wrong loop behavior.

Using '===' may cause strict comparison issues.

Using '==' or '===' instead of '=' for assignment causes errors.

Use '!==' to check nodes exist and '=' to remove last node by setting next to null.

Practice

1. What does the operation Delete Node at End do in a singly 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. Removes the last node from the linked list

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

Solution

1. Step 1: Understand the linked list structure

   A singly linked list is a chain of nodes where each node points to the next node, ending with a node pointing to null.

2. Step 2: Identify what deleting the last node means

   Deleting the last node means removing the node that points to null, effectively shortening the list by one node at the end.

3. Final Answer:

   Removes the last node from the linked list -> Option C

4. Quick Check:

   Delete Node at End = Remove last node [OK]

Hint: Last node points to null; delete it to remove end [OK]

Common Mistakes:

• Confusing delete at end with delete at start
• Thinking it adds a node instead of removing
• Assuming it deletes a middle node

2. Which of the following is the correct syntax to delete the last node in a singly linked list in JavaScript?

easy

A. list.deleteEnd();

B. list.pop();

C. list.deleteNodeAtEnd();

D. list.removeLastNode();

Solution

1. Step 1: Recognize common JavaScript linked list methods

   JavaScript arrays use pop() to remove the last element; custom linked lists often implement similar methods.

2. Step 2: Identify the standard method name

   Among the options, pop() is the standard method name used to remove the last element in many list implementations.

3. Final Answer:

   list.pop(); -> Option B

4. Quick Check:

   pop() removes last element [OK]

Hint: pop() usually removes last element in lists [OK]

Common Mistakes:

• Using non-standard method names
• Confusing delete with remove
• Assuming deleteEnd() is built-in

3. Consider the following JavaScript code for a singly linked list deletion at end:

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

class LinkedList {
  constructor() {
    this.head = null;
  }

  deleteAtEnd() {
    if (!this.head) return null;
    if (!this.head.next) {
      this.head = null;
      return;
    }
    let current = this.head;
    while (current.next.next) {
      current = current.next;
    }
    current.next = null;
  }
}

let list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.deleteAtEnd();

let result = [];
let temp = list.head;
while(temp) {
  result.push(temp.data);
  temp = temp.next;
}
console.log(result);

What will be printed?

medium

A. [1, 2, 3]

B. [2, 3]

C. [1]

D. [1, 2]

Solution

1. Step 1: Understand the initial list and deletion

   The list starts as 1 -> 2 -> 3. The deleteAtEnd() method removes the last node (3).

2. Step 2: Trace the deletion and final list

   After deletion, the list becomes 1 -> 2. The loop collects these values into the array [1, 2].

3. Final Answer:

   [1, 2] -> Option D

4. Quick Check:

   Deleting last node removes 3, leaving [1, 2] [OK]

Hint: Deleting end removes last node, so last value drops [OK]

Common Mistakes:

• Forgetting to update the second last node's next to null
• Assuming the head changes incorrectly
• Not handling single-node list case

4. The following code tries to delete the last node of a singly linked list but causes an error:

deleteAtEnd() {
  let current = this.head;
  while (current.next) {
    current = current.next;
  }
  current = null;
}

What is the main problem?

medium

A. It sets the local variable to null but does not update the list

B. It does not handle empty list case

C. It deletes the head node instead of last node

D. It causes infinite loop

Solution

1. Step 1: Analyze the loop and pointer update

   The loop moves current to the last node, but setting current = null only changes the local variable, not the list's links.

2. Step 2: Understand why the last node is not removed

   To remove the last node, the previous node's next must be set to null. This code misses that step.

3. Final Answer:

   It sets the local variable to null but does not update the list -> Option A

4. Quick Check:

   Local variable null doesn't remove node [OK]

Hint: Update previous node's next, not local pointer [OK]

Common Mistakes:

• Setting current to null instead of previous.next
• Not checking for single-node list
• Ignoring empty list case

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40. You want to delete the last node and then add a new node with value 50 at the end. Which sequence of operations correctly achieves this?

hard

A. Call deleteAtEnd(), then call addAtEnd(50)

B. Call addAtEnd(50), then call deleteAtEnd()

C. Call deleteAtEnd() twice, then addAtEnd(50)

D. Call deleteAtEnd(), then addAtStart(50)

Solution

1. Step 1: Delete the last node

   Calling deleteAtEnd() removes the node with value 40, list becomes 10 -> 20 -> 30.

2. Step 2: Add new node at the end

   Calling addAtEnd(50) adds a new node with value 50 at the end, list becomes 10 -> 20 -> 30 -> 50.

3. Final Answer:

   Call deleteAtEnd(), then call addAtEnd(50) -> Option A

4. Quick Check:

   Delete last then add new last node [OK]

Hint: Delete last first, then add new node at end [OK]

Common Mistakes:

• Adding before deleting causes wrong order
• Deleting twice removes too many nodes
• Adding at start changes list order