Delete a Node from Circular Linked List in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a circular linked list?

A circular linked list is a linked list where the last node points back to the first node, forming a circle. There is no null at the end.

intermediate

Why is deleting a node from a circular linked list different from a singly linked list?

Because the last node points back to the head, we must update the last node's next pointer if we delete the head. Also, we must handle the circular link carefully to avoid breaking the circle.

intermediate

What steps do you follow to delete a node with a given value from a circular linked list?

1. Find the node to delete and its previous node.
2. If the node is the only node, set head to null.
3. If deleting head, update head to next node.
4. Update previous node's next pointer to skip the deleted node.
5. Maintain the circular link.

beginner

What happens if you delete the only node in a circular linked list?

The list becomes empty, so the head pointer should be set to null to indicate the list has no nodes.

intermediate

How do you handle deleting the head node in a circular linked list?

You find the last node to update its next pointer to the new head (which is head.next), then update the head pointer to head.next.

In a circular linked list, what does the last node point to?

A Itself

B Null

C The first node

D The previous node

In a circular linked list, the last node points back to the first node, forming a circle.

What should you do if the node to delete is the only node in the circular linked list?

A Set head to null

B Set head to itself

C Do nothing

D Create a new node

If the only node is deleted, the list becomes empty, so head should be set to null.

When deleting the head node in a circular linked list, what must you update?

A Only the head pointer

B The last node's next pointer and the head pointer

C Only the last node's next pointer

D Nothing

You must update the last node's next pointer to the new head and update the head pointer itself.

If you want to delete a node with value X, what is the first step?

A Find the node with value X and its previous node

B Delete the head node

C Set head to null

D Create a new node

You first find the node to delete and its previous node to update pointers correctly.

What happens if you forget to update the last node's next pointer when deleting the head?

A The head pointer will be null

B The list remains circular

C The list will have duplicate nodes

D The list will break and no longer be circular

If the last node's next pointer is not updated, the circular link breaks and the list is corrupted.

Explain how to delete a node from a circular linked list, including special cases.

Think about how the circle is maintained and what happens if the node is head or the only node.

Describe the difference between deleting a node in a singly linked list and a circular linked list.

Focus on how the end of the list is connected.

Practice

1. What happens when you delete the head node from a circular linked list with multiple nodes?

easy

A. The head moves to the next node and the list remains circular

B. The list becomes empty immediately

C. The last node points to null breaking the circle

D. The list throws an error and stops

Solution

1. Step 1: Understand the head deletion in circular list

   When the head node is deleted, the next node becomes the new head.

2. Step 2: Maintain circular link

   The last node's next pointer is updated to point to the new head, keeping the list circular.

3. Final Answer:

   The head moves to the next node and the list remains circular -> Option A

4. Quick Check:

   Head deletion updates head and last node pointer [OK]

Hint: Head deletion shifts head and keeps circle intact [OK]

Common Mistakes:

• Assuming list becomes empty after head deletion
• Breaking the circular link by setting last node to null
• Not updating the last node's next pointer

2. Which of the following is the correct syntax to delete a node with value `key` from a circular linked list in JavaScript?

easy

A. function deleteNode(head) { /* code */ }

B. function deleteNode(key, head) { /* code */ }

C. function deleteNode(head, key) { /* code */ }

D. function deleteNode() { /* code */ }

Solution

1. Step 1: Identify function parameters for deletion

   The function needs the head of the list and the key value to delete the correct node.

2. Step 2: Confirm correct parameter order

   The common and clear order is (head, key) to access the list and the target value.

3. Final Answer:

   function deleteNode(head, key) { /* code */ } -> Option C

4. Quick Check:

   Parameters: head and key in order [OK]

Hint: Function needs head and key parameters in order [OK]

Common Mistakes:

• Swapping parameter order causing confusion
• Missing key parameter to identify node
• Using no parameters making deletion impossible

3. What will be the output after deleting node with value 3 from this circular linked list: 1 -> 3 -> 5 -> 7 -> (back to 1)?
<pre>function deleteNode(head, key) { if (!head) return null; let curr = head, prev = null; do { if (curr.data === key) { if (prev) prev.next = curr.next; else { let temp = head; while (temp.next !== head) temp = temp.next; head = curr.next; temp.next = head; } break; } prev = curr; curr = curr.next; } while (curr !== head); return head; } // After deletion, print list starting from head

medium

A. 1 -> 5 -> 7 -> (back to 1)

B. 3 -> 5 -> 7 -> (back to 3)

C. 1 -> 3 -> 5 -> 7 -> (back to 1)

D. 5 -> 7 -> 1 -> (back to 5)

Solution

1. Step 1: Locate node with value 3

   The code loops through nodes and finds node with data 3.

2. Step 2: Delete node 3 and update links

   Since node 3 is not head, prev.next skips node 3 and points to node 5, maintaining circular link.

3. Final Answer:

   1 -> 5 -> 7 -> (back to 1) -> Option A

4. Quick Check:

   Node 3 removed, list links updated [OK]

Hint: Skip deleted node by linking previous to next [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Deleting head incorrectly when key is not head
• Breaking circular link by missing last node update

4. Identify the bug in this code snippet for deleting a node from a circular linked list:

function deleteNode(head, key) {
  if (!head) return null;
  let curr = head;
  while (curr.next !== head) {
    if (curr.next.data === key) {
      curr.next = curr.next.next;
      return head;
    }
    curr = curr.next;
  }
  return head;
}

medium

A. Infinite loop due to missing break

B. Does not handle deletion when head node has the key

C. Deletes multiple nodes with the key instead of one

D. Returns null even if list is not empty

Solution

1. Step 1: Analyze loop and deletion logic

   The loop checks curr.next for key but never checks head node itself.

2. Step 2: Identify missing head deletion case

   If head node contains key, this code does not delete it, causing incorrect behavior.

3. Final Answer:

   Does not handle deletion when head node has the key -> Option B

4. Quick Check:

   Head node deletion missing in logic [OK]

Hint: Always check head node separately for deletion [OK]

Common Mistakes:

• Ignoring head node deletion case
• Assuming loop covers all nodes including head
• Not updating head pointer when head is deleted

5. Given a circular linked list with nodes 10 -> 20 -> 30 -> 40 -> (back to 10), how would you delete the last node (40) and maintain the circular structure? Choose the correct approach.

hard

A. Swap last node data with head and delete head

B. Set head to null directly to delete last node

C. Change last node's next to null to break the circle

D. Traverse to node before last, set its next to head, and delete last node

Solution

1. Step 1: Find node before last node

   Traverse list until node.next.next equals head, identifying node before last.

2. Step 2: Update next pointer and delete last node

   Set node before last's next pointer to head, removing last node and keeping list circular.

3. Final Answer:

   Traverse to node before last, set its next to head, and delete last node -> Option D

4. Quick Check:

   Update second last node's next to head [OK]

Hint: Link second last node directly to head [OK]

Common Mistakes:

• Breaking circle by setting next to null
• Deleting head instead of last node
• Not updating pointers causing broken list