Delete Node at End in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Delete Node at End' mean in a linked list?

It means removing the last node from the linked list, so the second last node becomes the new end.

beginner

In a singly linked list, why do we need to traverse the list to delete the last node?

Because each node only knows the next node, we must find the second last node to update its next pointer to null.

beginner

What happens if we try to delete the last node in an empty linked list?

Nothing happens because the list is empty; there is no node to delete.

intermediate

What is the time complexity of deleting the last node in a singly linked list?

O(n), because we need to traverse the list to find the second last node.

intermediate

Show the JavaScript code snippet to delete the last node from a singly linked list.

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

What pointer do we update when deleting the last node in a singly linked list?

A The previous pointer of the last node

B The head pointer

C The next pointer of the second last node

D The next pointer of the last node

We update the next pointer of the second last node to null to remove the last node.

What is the result of deleting the last node from a list with only one node?

A The list remains the same

B An error occurs

C The head points to the deleted node

D The list becomes empty

Deleting the only node leaves the list empty (head becomes null).

Which of these is true about deleting the last node in a singly linked list?

A It requires traversing the list to find the second last node

B It can be done in O(1) time without traversal

C It requires updating the head pointer always

D It is impossible

Because nodes only point forward, we must find the second last node to update its next pointer.

What happens if you try to delete the last node from an empty list?

A The list crashes

B Nothing, the list stays empty

C A new node is added

D The head pointer is set to a new node

Deleting from an empty list does nothing; the list remains empty.

In the code snippet for deleting the last node, what does 'current.next = null' do?

A Removes the last node by breaking the link

B Adds a new node at the end

C Moves the head pointer

D Deletes the entire list

Setting current.next to null removes the last node by breaking the link to it.

Explain step-by-step how to delete the last node in a singly linked list.

Think about how nodes point only forward and how to find the node before the last.

Write a simple JavaScript function to delete the last node from a singly linked list and explain its logic.

Use a loop to find the node before the last and then remove the last node.

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