Delete a Node from Circular Linked List in DSA C++ - 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. Each player has a unique ID number. Sometimes a player leaves the game, and you need to remove that player from the circle without breaking the circle.

🎯 Goal: Build a program that creates a circular linked list of players, then deletes a player with a specific ID from the list, and finally prints the remaining players in order.

📋 What You'll Learn

Create a circular linked list with exactly 5 nodes having player IDs: 10, 20, 30, 40, 50

Create an integer variable called deleteID with the value 30

Write a function called deleteNode that deletes the node with the player ID equal to deleteID from the circular linked list

Print the player IDs of the circular linked list after deletion in the format: 10 -> 20 -> 40 -> 50 -> (back to head)

💡 Why This Matters

🌍 Real World

Circular linked lists are useful in real-world scenarios like managing players in a round-robin game, scheduling tasks in a loop, or buffering data streams.

💼 Career

Understanding circular linked lists and node deletion is important for software engineers working on systems involving cyclic data structures, real-time scheduling, or game development.

1

Create the Circular Linked List

Create a circular linked list with 5 nodes having player IDs 10, 20, 30, 40, and 50. Use a struct called Node with an integer data and a Node* called next. Create a pointer called head that points to the first node.

DSA C++

// Define struct Node
// Create nodes with data 10, 20, 30, 40, 50
// Link nodes in a circle
// Set head to first node
// Your code here

Hint

Remember to link the last node back to the head to make the list circular.

2

Set the Player ID to Delete

Create an integer variable called deleteID and set it to 30. This is the player ID you want to remove from the circular linked list.

DSA C++

#include 
using namespace std;

struct Node {
    int data;
    Node* next;
};

int main() {
    Node* head = new Node{10, nullptr};
    Node* second = new Node{20, nullptr};
    Node* third = new Node{30, nullptr};
    Node* fourth = new Node{40, nullptr};
    Node* fifth = new Node{50, nullptr};

    head->next = second;
    second->next = third;
    third->next = fourth;
    fourth->next = fifth;
    fifth->next = head; // circular link

    // Create deleteID variable and set to 30
    // Your code here

    return 0;
}

Hint

Just create an integer variable named deleteID and assign 30 to it.

3

Write the Function to Delete the Node

Write a function called deleteNode that takes two parameters: a pointer to the head node called head and an integer key. The function should delete the node with data == key from the circular linked list and return the new head pointer. Use this function inside main to delete the node with player ID equal to deleteID.

DSA C++

#include 
using namespace std;

struct Node {
    int data;
    Node* next;
};

Node* deleteNode(Node* head, int key) {
    // Implement deletion of node with data == key
    // Your code here
}

int main() {
    Node* head = new Node{10, nullptr};
    Node* second = new Node{20, nullptr};
    Node* third = new Node{30, nullptr};
    Node* fourth = new Node{40, nullptr};
    Node* fifth = new Node{50, nullptr};

    head->next = second;
    second->next = third;
    third->next = fourth;
    fourth->next = fifth;
    fifth->next = head; // circular link

    int deleteID = 30;

    head = deleteNode(head, deleteID);

    return 0;
}

Hint

Handle deleting the head node separately. For other nodes, find the node and update the previous node's next pointer.

4

Print the Circular Linked List After Deletion

Write code to print the player IDs in the circular linked list starting from head. Print the IDs separated by -> and end with (back to head). For example: 10 -> 20 -> 40 -> 50 -> (back to head)

DSA C++

#include 
using namespace std;

struct Node {
    int data;
    Node* next;
};

Node* deleteNode(Node* head, int key) {
    if (head == nullptr) return nullptr;

    Node *curr = head, *prev = nullptr;

    if (head->data == key && head->next == head) {
        delete head;
        return nullptr;
    }

    if (head->data == key) {
        Node* last = head;
        while (last->next != head) {
            last = last->next;
        }
        last->next = head->next;
        Node* temp = head;
        head = head->next;
        delete temp;
        return head;
    }

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

    if (curr->data == key) {
        prev->next = curr->next;
        delete curr;
    }

    return head;
}

int main() {
    Node* head = new Node{10, nullptr};
    Node* second = new Node{20, nullptr};
    Node* third = new Node{30, nullptr};
    Node* fourth = new Node{40, nullptr};
    Node* fifth = new Node{50, nullptr};

    head->next = second;
    second->next = third;
    third->next = fourth;
    fourth->next = fifth;
    fifth->next = head; // circular link

    int deleteID = 30;

    head = deleteNode(head, deleteID);

    // Print the circular linked list
    // Your code here

    return 0;
}

Hint

Use a do-while loop to print nodes starting from head until you come back to head.

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 one node pointing to itself.

C. The list becomes a linear linked list.

D. The list throws an error and stops.

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 leaves no nodes, so head becomes null.

3. Final Answer:

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

4. Quick Check:

   Single node deleted = empty list [OK]

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

Common Mistakes:

• Assuming list still has one node after deletion
• Not updating head to null
• Confusing circular with linear list after deletion

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

easy

A. void deleteNode(Node head, int key) { /* code */ }

B. void deleteNode(Node* head, int key) { /* code */ }

C. void deleteNode(Node*& head, int key) { /* code */ }

D. void deleteNode(int key, Node* head) { /* code */ }

Solution

1. Step 1: Understand pointer passing in C++

   To modify the head pointer itself, pass it by reference (Node*& head).

2. Step 2: Check parameter order and types

   Function should accept head reference first, then key to delete.

3. Final Answer:

   void deleteNode(Node*& head, int key) { /* code */ } -> Option C

4. Quick Check:

   Pass head by reference to modify it [OK]

Hint: Pass head as reference to update list head [OK]

Common Mistakes:

• Passing head by value (won't update original list)
• Wrong parameter order
• Passing head as object, not pointer or reference

3. Given the circular linked list: 10 -> 20 -> 30 -> (back to 10), what is the list after deleting node with value 20?

medium

A. 10 -> 20 -> 30 -> (back to 10)

B. 10 -> 30 -> (back to 10)

C. 20 -> 30 -> (back to 20)

D. 30 -> 10 -> (back to 30)

Solution

1. Step 1: Identify node to delete

   Node with value 20 is between 10 and 30.

2. Step 2: Remove node 20 and link 10 to 30

   Update 10's next pointer to 30, maintaining circular link.

3. Final Answer:

   10 -> 30 -> (back to 10) -> Option B

4. Quick Check:

   Deleted 20, linked 10 to 30 [OK]

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

Common Mistakes:

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

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

void deleteNode(Node*& head, int key) {
  if (!head) return;
  Node* curr = head;
  while (curr->next != head && curr->next->data != key) {
    curr = curr->next;
  }
  if (curr->next->data == key) {
    Node* temp = curr->next;
    curr->next = temp->next;
    delete temp;
  }
}

medium

A. Does not handle deleting the head node correctly.

B. Does not check if list is empty.

C. Deletes node without updating pointers.

D. Infinite loop due to wrong while condition.

Solution

1. Step 1: Analyze deletion logic

   Code searches for node before target and deletes next node.

2. Step 2: Check head deletion case

   If node to delete is head, head pointer is not updated, causing errors.

3. Final Answer:

   Does not handle deleting the head node correctly. -> Option A

4. Quick Check:

   Head deletion needs special handling [OK]

Hint: Update head if deleted node is head [OK]

Common Mistakes:

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

5. You have a circular linked list: 5 -> 15 -> 25 -> 35 -> (back to 5). You want to delete the node with value 5 (head node). Which steps correctly update the list?

hard

A. Swap head data with next node and delete next node.

B. Delete head node directly without updating last node's next.

C. Set head to null without deleting any node.

D. Find last node (35), set its next to head's next (15), update head to 15.

Solution

1. Step 1: Locate last node

   Traverse list to find node pointing to head (value 35).

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

   Set last node's next to head's next (node with value 15).

3. Step 3: Update head pointer

   Set head to head's next (15) to maintain circular list.

4. Final Answer:

   Find last node (35), set its next to head's next (15), update head to 15. -> Option D

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
• Not updating head pointer
• Deleting head without fixing links