Delete a Node from Circular Linked List in DSA C# - Build from Scratch

Delete a Node from Circular Linked List

📖 Scenario: Imagine you have a circular linked list representing players sitting around a round table. Each player has a unique number. Sometimes a player leaves the game, and you need to remove that player from the circle without breaking the circle.

🎯 Goal: You will create a circular linked list, set up a target player number to remove, write the logic to delete that player from the circular linked list, and finally print the updated circle of players.

📋 What You'll Learn

Create a circular linked list with nodes containing integers 1, 2, 3, 4, 5

Create an integer variable called target with value 3 to represent the player to remove

Write a method DeleteNode that removes the node with value equal to target from the circular linked list

Print the circular linked list after deletion in the format: 1 -> 2 -> 4 -> 5 -> (back to 1)

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real-world applications like multiplayer games to cycle through players, music playlists that loop, and operating system task scheduling.

💼 Career

Understanding circular linked lists and node deletion is important for software developers working on systems that require efficient cyclic data traversal and modification.

1

Create the Circular Linked List

Create a class called Node with an integer data and a Node reference called next. Then create 5 nodes with data 1, 2, 3, 4, 5 and link them in a circular way so that the last node points back to the first node. Store the first node in a variable called head.

DSA C#

// Define Node class and create circular linked list with nodes 1 to 5
// Your code here

Hint

Remember to link the last node's next to the head to make the list circular.

2

Set the Target Node to Delete

Create an integer variable called target and set it to 3. This represents the player number to remove from the circular linked list.

DSA C#

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

Node head = new Node(1);
Node second = new Node(2);
Node third = new Node(3);
Node fourth = new Node(4);
Node fifth = new Node(5);

head.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = head; // circular link

// Create target variable with value 3
// Your code here

Hint

Just create an integer variable named target and assign it the value 3.

3

Write the DeleteNode Method

Write a method called DeleteNode that takes Node head and int target as parameters and returns the new head of the circular linked list after deleting the node with data equal to target. Handle these cases: if the list is empty, if the node to delete is the head, and if the node is in the middle or end. If the node is not found, return the original head.

DSA C#

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

Node head = new Node(1);
Node second = new Node(2);
Node third = new Node(3);
Node fourth = new Node(4);
Node fifth = new Node(5);

head.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = head; // circular link

int target = 3;

// Write DeleteNode method below
// Your code here

Hint

Remember to handle deleting the head node differently because you must update the last node's next pointer.

4

Print the Circular Linked List After Deletion

Call the DeleteNode method with head and target, update head with the returned value, then print the circular linked list starting from head in the format: 1 -> 2 -> 4 -> 5 -> (back to 1). Use a do-while loop to traverse the circular list.

DSA C#

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

Node head = new Node(1);
Node second = new Node(2);
Node third = new Node(3);
Node fourth = new Node(4);
Node fifth = new Node(5);

head.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = head; // circular link

int target = 3;

Node DeleteNode(Node head, int target)
{
    if (head == null) return null;

    Node current = head;
    Node prev = null;

    // If head is the only node and matches target
    if (head.data == target && head.next == head)
    {
        return null;
    }

    // If head needs to be deleted
    if (head.data == target)
    {
        // Find last node to update its next
        Node last = head;
        while (last.next != head)
        {
            last = last.next;
        }
        head = head.next;
        last.next = head;
        return head;
    }

    // For other nodes
    prev = head;
    current = head.next;
    while (current != head)
    {
        if (current.data == target)
        {
            prev.next = current.next;
            return head;
        }
        prev = current;
        current = current.next;
    }

    // Target not found
    return head;
}

// Call DeleteNode and print the list
// Your code here

Hint

Use a do-while loop to print all nodes starting from head until you reach head again.

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