Delete a Node from Circular Linked List in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting a node with value 3

What is the printed state of the circular linked list after deleting the node with value 3?

DSA C#

public class Node {
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class CircularLinkedList {
    public Node head = null;

    public void Append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            newNode.next = head;
            return;
        }
        Node temp = head;
        while (temp.next != head) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.next = head;
    }

    public void DeleteNode(int key) {
        if (head == null) return;

        Node curr = head, prev = null;

        // If head is to be deleted
        if (head.data == key) {
            if (head.next == head) {
                head = null;
                return;
            }
            Node last = head;
            while (last.next != head) {
                last = last.next;
            }
            head = head.next;
            last.next = head;
            return;
        }

        prev = head;
        curr = head.next;
        while (curr != head && curr.data != key) {
            prev = curr;
            curr = curr.next;
        }

        if (curr != head && curr.data == key) {
            prev.next = curr.next;
        }
    }

    public string PrintList() {
        if (head == null) return "null";
        Node temp = head;
        string result = "";
        do {
            result += temp.data + " -> ";
            temp = temp.next;
        } while (temp != head);
        result += "null";
        return result;
    }
}

var cll = new CircularLinkedList();
cll.Append(1);
cll.Append(2);
cll.Append(3);
cll.Append(4);
cll.DeleteNode(3);
Console.WriteLine(cll.PrintList());

A 1 -> 4 -> null

B 1 -> 2 -> 3 -> 4 -> null

C 2 -> 3 -> 4 -> null

D 1 -> 2 -> 4 -> null

💡 Hint

Focus on how the DeleteNode method removes the node with the given key and updates the links.

The node with value 3 is removed. The list links 2 directly to 4, maintaining circularity. The printed output shows the list starting from head (1) and ending with null.

❓ Predict Output

intermediate

Output after deleting the head node

What is the printed state of the circular linked list after deleting the node with value 1 (the head)?

DSA C#

var cll = new CircularLinkedList();
cll.Append(1);
cll.Append(2);
cll.Append(3);
cll.Append(4);
cll.DeleteNode(1);
Console.WriteLine(cll.PrintList());

A 2 -> 3 -> 4 -> null

B 1 -> 2 -> 3 -> 4 -> null

C 3 -> 4 -> null

D null

💡 Hint

Deleting the head node requires updating the head pointer and the last node's next pointer.

Deleting the head (1) moves the head to the next node (2) and updates the last node's next to the new head, preserving circularity.

🔧 Debug

advanced

Identify the error in DeleteNode method when deleting a non-existent node

What happens when DeleteNode is called with a key not present in the list? Identify the error or behavior.

DSA C#

cll.DeleteNode(5);

A Infinite loop because curr never reaches head

B Deletes the last node by mistake

C NullReferenceException due to accessing curr.data when curr is head

D No change; list remains intact without error

💡 Hint

Check the while loop condition and what happens after it ends when key is not found.

When key is not found, curr becomes head again. The code then tries to access curr.data without checking if key was found, causing NullReferenceException.

🚀 Application

advanced

How to delete the only node in a circular linked list?

Given a circular linked list with a single node, what is the correct way to delete that node?

A Set head.data to 0

B Set head to null

C Set head.next to null

D Set head.next to head

💡 Hint

Deleting the only node means the list becomes empty.

When the list has only one node, deleting it means the list is empty, so head should be set to null.

🧠 Conceptual

expert

Why is it necessary to update the last node's next pointer when deleting the head?

In a circular linked list, why must the last node's next pointer be updated when the head node is deleted?

A To maintain the circular link so the list remains connected

B To update the head's data to the last node's data

C To prevent memory leaks by breaking the link

D To reverse the list order after deletion

💡 Hint

Think about what keeps the circular linked list connected.

The last node points to the head to keep the list circular. When head changes, last node's next must point to the new head to maintain the circle.

Practice

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

easy

A. The list becomes a linear linked list.

B. The list still contains one node pointing to itself.

C. The list becomes empty (null).

D. The list throws an error.

Solution

1. Step 1: Understand the structure of a single-node circular linked list

   In a circular linked list with one node, the node points to itself.

2. Step 2: Delete the only node

   Removing this node leaves no nodes, so the list becomes empty (null).

3. Final Answer:

   The list becomes empty (null). -> Option C

4. Quick Check:

   Deleting the only node empties the list [OK]

Hint: Deleting last node empties the list, no nodes remain [OK]

Common Mistakes:

• Assuming list still has one node after deletion
• Thinking list becomes linear instead of empty
• Expecting an error on deletion

2. Which of the following is the correct way to update the head pointer when deleting the head node in a circular linked list?

easy

A. head = head.next;

B. head = null;

C. head = head.prev;

D. head = head.next.next;

Solution

1. Step 1: Identify the new head after deleting the current head

   When deleting the head node, the new head should be the next node in the list.

2. Step 2: Update the head pointer

   Assign head to head.next to point to the next node.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   New head is next node after deletion [OK]

Hint: After deleting head, move head pointer to next node [OK]

Common Mistakes:

• Setting head to null incorrectly
• Using head.prev which is invalid in singly circular list
• Skipping updating head pointer

3. What will be the output after deleting node with value 3 from the circular linked list: 1 -> 2 -> 3 -> 4 -> (back to 1)?

Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = head;
// Delete node with value 3
// After deletion, print list starting from head

medium

A. 2 -> 3 -> 4 -> (back to 2)

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

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

D. 1 -> 2 -> 4 -> (back to 1)

Solution

1. Step 1: Identify node to delete and its previous node

   Node with value 3 is after node with value 2.

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

   Set node 2's next to node 4, skipping node 3.

3. Final Answer:

   1 -> 2 -> 4 -> (back to 1) -> Option D

4. Quick Check:

   Node 3 removed, list links 2 to 4 [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. Given this code snippet to delete a node from a circular linked list, what is the bug?

Node current = head;
while (current.next != head && current.next.data != key) {
    current = current.next;
}
if (current.next.data == key) {
    current.next = current.next.next;
}

medium

A. Does not handle deleting the head node correctly.

B. Does not update head pointer after deletion.

C. Deletes multiple nodes instead of one.

D. Infinite loop if key not found.

Solution

1. Step 1: Analyze deletion logic

   The code finds the node before the target and skips the target node.

2. Step 2: Check head pointer update

   If the deleted node is head, head pointer is not updated, causing inconsistency.

3. Final Answer:

   Does not update head pointer after deletion. -> Option B

4. Quick Check:

   Head pointer must update if head node deleted [OK]

Hint: Always update head if deleted node is head [OK]

Common Mistakes:

• Ignoring head pointer update
• Assuming deletion always non-head
• Not checking if key exists

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

hard

A. Find last node, set its next to head.next, update head to head.next.

B. Set head to null directly.

C. Set head to head.next without changing last node's next.

D. Remove head and leave last node pointing to null.

Solution

1. Step 1: Find the last node in the circular list

   Traverse nodes until node.next == head to find last node (node with value 40).

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

   Set last node's next to head.next (node 20), then update head to head.next.

3. Final Answer:

   Find last node, set its next to head.next, update head to head.next. -> Option A

4. Quick Check:

   Last node points to new head, list remains circular [OK]

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

Common Mistakes:

• Not updating last node's next pointer
• Setting head to null incorrectly
• Breaking circular link by pointing to null