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

Delete a Node from Circular Linked List

📖 Scenario: You are managing a circular linked list that represents players sitting around a round table in a game. Sometimes a player leaves the game, and you need to remove that player from the circle without breaking the circle structure.

🎯 Goal: Build a Java program that creates a circular linked list of players, sets a player name to delete, removes that player from the circular linked list, and then prints the updated list of players in the circle.

📋 What You'll Learn

Create a circular linked list with nodes containing player names

Add a variable to hold the player name to delete

Write the logic to delete the node with the given player name from the circular linked list

Print the circular linked list after deletion showing all remaining players

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real-world applications like multiplayer games to manage players in a round-robin fashion, where the turn cycles continuously.

💼 Career

Understanding circular linked lists and node deletion is important for software engineers working on systems requiring cyclic data structures, such as operating systems, network scheduling, and game development.

1

Create Circular Linked List with Players

Create a class called Node with a String name and a Node next. Then create a circular linked list with these exact player names in order: "Alice", "Bob", "Charlie", "Diana". Store the reference to the head node in a variable called head.

DSA Java

class Node {
    String name;
    Node next;

    Node(String name) {
        this.name = name;
        this.next = null;
    }
}

// Create circular linked list with players
// Your code here

Hint

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

2

Add Player Name to Delete

Add a String variable called playerToDelete and set it to "Charlie".

DSA Java

class Node {
    String name;
    Node next;

    Node(String name) {
        this.name = name;
        this.next = null;
    }
}

public class CircularLinkedList {
    public static void main(String[] args) {
        Node head = new Node("Alice");
        Node second = new Node("Bob");
        Node third = new Node("Charlie");
        Node fourth = new Node("Diana");

        head.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = head; // Make it circular

        // Add playerToDelete variable below
        // Your code here
    }
}

Hint

Just create a String variable with the exact name and value.

3

Delete the Node with Given Player Name

Write code to delete the node with the name stored in playerToDelete from the circular linked list starting at head. Handle the case where the node to delete is the head node or any other node. Update head if the head node is deleted.

DSA Java

        if (head == null) return;
        Node current = head;
        Node prev = null;
        // If head needs to be deleted
        if (head.name.equals(playerToDelete)) {
            // Find last node to update its next
            while (current.next != head) {
                current = current.next;
            }
            if (head.next == head) {
                // Only one node
                head = null;
            } else {
                current.next = head.next;
                head = head.next;
            }
        } else {
            prev = head;
            current = head.next;
            while (current != head) {
                if (current.name.equals(playerToDelete)) {
                    prev.next = current.next;
                    break;
                }
                prev = current;
                current = current.next;
            }
        }
        // Print the circular linked list

Hint

Check if the head node is the one to delete first. Then find the last node to update its next pointer. For other nodes, traverse and unlink the matching node.

4

Print the Circular Linked List After Deletion

Write a while loop to print all player names in the circular linked list starting from head. Print the names separated by " -> " and end with " -> (head)" to show the circular link. If the list is empty (head == null), print "List is empty".

DSA Java

Hint

Use a do-while loop to traverse the circular list and print each node's name. End with (head) to show the circle.

Practice

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

easy

A. The list becomes empty (head points to null)

B. The list still contains the deleted node

C. The list forms a linear linked list

D. The list throws an error automatically

Solution

1. Step 1: Understand single node deletion

   When the only node is deleted, no nodes remain in the list.

2. Step 2: Resulting list state

   The head pointer is set to null, indicating an empty list.

3. Final Answer:

   The list becomes empty (head points to null) -> Option A

4. Quick Check:

   Deleting last node empties list [OK]

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

Common Mistakes:

• Assuming list still has nodes after deletion
• Not setting head to null
• Confusing circular with linear list after deletion

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

easy

A. head = tail; tail.next = null;

B. head = null; tail = null;

C. head = head.prev; tail.next = head;

D. head = head.next; tail.next = head;

Solution

1. Step 1: Update head pointer

   When deleting the head node, move head to next node.

2. Step 2: Maintain circular link

   Update tail's next pointer to new head to keep circular structure.

3. Final Answer:

   head = head.next; tail.next = head; -> Option D

4. Quick Check:

   Head moves forward, tail links to new head [OK]

Hint: After deleting head, point tail.next to new head [OK]

Common Mistakes:

• Setting tail.next to null breaks circular link
• Setting head to null incorrectly
• Using head.prev which doesn't exist in singly circular list

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

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

medium

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

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

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

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

Solution

1. Step 1: Locate node with value 3

   Traverse list: 1 -> 2 -> 3 found.

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

   Set n2.next = n3.next (which is n4), skipping node 3.

3. Final Answer:

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

4. Quick Check:

   Node 3 removed, list links 2 to 4 [OK]

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

Common Mistakes:

• Not updating previous node's next pointer
• Breaking circular link by missing tail update
• Deleting wrong node or skipping nodes

4. Identify the error in this code snippet that deletes a node with value 'key' from a circular linked list:

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 deletion when list has only one node

B. Infinite loop if key not found

C. Does not update tail pointer when deleting last node

D. Deletes head node incorrectly

Solution

1. Step 1: Check tail update on deletion

   If deleted node is tail, tail pointer must update to current node.

2. Step 2: Code misses tail update

   Code only changes current.next, tail remains pointing to deleted node.

3. Final Answer:

   Does not update tail pointer when deleting last node -> Option C

4. Quick Check:

   Tail pointer must update if last node deleted [OK]

Hint: Update tail if deleting last node [OK]

Common Mistakes:

• Ignoring tail pointer update
• Assuming tail auto-updates
• Not checking if deleted node is tail

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

hard

A. Set head = null; tail = null;

B. Set head = head.next; tail.next = head; delete old head;

C. Set tail.next = head.next; head = head.next;

D. Set tail = head; head = head.next; tail.next = null;

Solution

1. Step 1: Move head to next node

   Set head = head.next to remove old head from start.

2. Step 2: Update tail's next pointer

   Set tail.next = head to maintain circular link.

3. Step 3: Delete old head node properly

   Remove old head node from memory if needed.

4. Final Answer:

   Set head = head.next; tail.next = head; delete old head; -> Option B

5. Quick Check:

   Head moves forward, tail links to new head [OK]

Hint: Update head and tail.next to new head when deleting head [OK]

Common Mistakes:

• Breaking circular link by setting tail.next to null
• Not moving head pointer
• Deleting head without updating tail.next