Delete a Node from Circular Linked List in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to move to the next node in the circular linked list.

DSA Go

current = current[1]

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

A.next

B.child

C.prev

D.parent

Attempts:

3 left

💡 Hint

Common Mistakes

Using .prev instead of .next

Using unrelated pointers like .child or .parent

In a circular linked list, each node points to the next node using the .next pointer.

2fill in blank

medium

Complete the code to check if the list has only one node.

DSA Go

if head[1] head.next {

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

A>

B!=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using != instead of ==

Using comparison operators like > or < which don't apply to pointers

If head points to itself (head == head.next), it means there is only one node in the circular linked list.

3fill in blank

hard

Fix the error in deleting the head node by updating the last node's next pointer.

DSA Go

last[1] = head.next

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

A.next

B.prev

C.child

D.parent

Attempts:

3 left

💡 Hint

Common Mistakes

Using .prev which points backward

Using unrelated pointers like .child or .parent

The last node's next pointer should point to the new head, which is head.next.

4fill in blank

hard

Fill both blanks to correctly remove a node from the circular linked list.

DSA Go

prev[1] = current[2]

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

A.next

B.prev

C.child

D.parent

Attempts:

3 left

💡 Hint

Common Mistakes

Using .prev instead of .next

Using unrelated pointers like .child or .parent

To remove a node, set the previous node's next pointer to the current node's next pointer.

5fill in blank

hard

Fill all three blanks to complete the function that deletes a node with a given key from a circular linked list.

DSA Go

func deleteNode(head *Node, key int) *Node {
    if head == nil {
        return nil
    }
    current := head
    var prev *Node
    for {
        if current.data == [1] {
            if prev != nil {
                prev[2] = current[3]
            } else {
                // handle deleting head node
            }
            break
        }
        prev = current
        current = current.next
        if current == head {
            break
        }
    }
    return head
}

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

Akey

B.next

D.prev

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pointer names like .prev for next pointers

Comparing with wrong variable instead of key

We compare current.data with key to find the node to delete. Then, we update prev.next to current.next to remove the node.

Practice

1. What happens when you delete the only node in a circular linked list?

easy

A. The list still contains the deleted node.

B. The list becomes empty (head points to nil).

C. The list forms a linear linked list.

D. The list throws an error automatically.

Solution

1. Step 1: Understand single-node circular list

   A circular linked list with one node points to itself.

2. Step 2: Delete the only node

   Removing this node means no nodes remain, so head becomes nil.

3. Final Answer:

   The list becomes empty (head points to nil). -> Option B

4. Quick Check:

   Single node deleted = empty list [OK]

Hint: Deleting last node empties the list, head = nil [OK]

Common Mistakes:

• Assuming list still has nodes after deleting the only node
• Not updating head to nil
• Confusing circular with linear list after deletion

2. Which Go syntax correctly moves the head pointer when deleting the head node from a circular linked list?

easy

A. head.next = head

B. head = nil.next

C. head = head.next

D. head = head.prev

Solution

1. Step 1: Identify head deletion logic

   Deleting head means moving head pointer to next node.

2. Step 2: Check syntax correctness

   Assigning head = head.next correctly moves head to next node.

3. Final Answer:

   head = head.next -> Option C

4. Quick Check:

   Move head to next node = head = head.next [OK]

Hint: Move head pointer to next node to delete head [OK]

Common Mistakes:

• Using nil.next causes runtime error
• Assigning head.next = head does not delete node
• Using head.prev is invalid for singly circular list

3. Given this circular linked list: 1 -> 2 -> 3 -> (back to 1), what is the list after deleting node with value 2?

medium

A. 1 -> 3 -> (back to 1)

B. 1 -> 2 -> 3 -> (back to 1)

C. 2 -> 3 -> (back to 2)

D. 3 -> 1 -> (back to 3)

Solution

1. Step 1: Locate node with value 2

   Node 2 is between nodes 1 and 3 in the circular list.

2. Step 2: Remove node 2 by linking 1 to 3

   Update node 1's next pointer to node 3, skipping node 2.

3. Final Answer:

   1 -> 3 -> (back to 1) -> Option A

4. Quick Check:

   Deleted 2, linked 1 to 3 [OK]

Hint: Link previous node to next of deleted node [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Deleting wrong node
• Breaking circular link

4. What is wrong with this Go code snippet for deleting a node from a circular linked list?

func deleteNode(head *Node, key int) *Node {
  if head == nil {
    return nil
  }
  curr := head
  for curr.next != head && curr.next.data != key {
    curr = curr.next
  }
  if curr.next.data == key {
    curr.next = curr.next.next
  }
  return head
}

medium

A. It returns nil always.

B. It causes infinite loop always.

C. It deletes all nodes with the key.

D. It does not handle deleting the head node correctly.

Solution

1. Step 1: Analyze deletion logic

   The code searches for node before target and skips target node.

2. Step 2: Check head deletion case

   If the node to delete is head, head pointer is not updated, causing incorrect list.

3. Final Answer:

   It does not handle deleting the head node correctly. -> Option D

4. Quick Check:

   Head deletion needs head pointer update [OK]

Hint: Update head if deleting head node [OK]

Common Mistakes:

• Ignoring head node deletion
• Not updating head pointer
• Assuming key always exists

5. You have a circular linked list: 10 -> 20 -> 30 -> 40 -> (back to 10). You want to delete node with value 10 (head). Which steps correctly update the list?

hard

A. Find last node (40), set its next to head.next (20), then update head to 20.

B. Set head to nil directly without updating last node.

C. Delete node 10 by setting head.next to nil.

D. Swap data of head and next node, then delete next node.

Solution

1. Step 1: Find last node pointing to head

   Traverse list to find node 40 which points to head (10).

2. Step 2: Update last node's next pointer

   Set node 40's next to head.next (node 20) to maintain circularity.

3. Step 3: Update head pointer

   Set head to head.next (node 20) to delete original head.

4. Final Answer:

   Find last node (40), set its next to head.next (20), then update head to 20. -> Option A

5. Quick Check:

   Update last node and head to delete head node [OK]

Hint: Update last node's next and head to delete head [OK]

Common Mistakes:

• Not updating last node's next pointer
• Setting head to nil breaks list
• Deleting node by setting next to nil