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 a round-robin schedule of tasks. Each node contains a task ID. You need to remove a specific task from this circular list when it is completed.

🎯 Goal: Build a C program that creates a circular linked list with given task IDs, sets a target task ID to delete, deletes the node with that task ID from the circular linked list, and prints the resulting list.

📋 What You'll Learn

Create a circular linked list with exact task IDs: 10, 20, 30, 40, 50

Create an integer variable target with value 30

Write a function deleteNode that deletes the node with value target from the circular linked list

Print 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 used in real-world applications like task scheduling, multiplayer games turn management, and buffering data streams where the list cycles continuously.

💼 Career

Understanding circular linked lists and node deletion is important for software engineers working on systems programming, embedded systems, and performance-critical applications.

1

Create the Circular Linked List

Define a struct Node with an integer data and a pointer next. Create five nodes with data 10, 20, 30, 40, and 50. Link them in a circular way so that the last node points back to the first node. Store the head pointer in head.

DSA C

// Define struct Node and create circular linked list with nodes 10, 20, 30, 40, 50
// Your code here

Hint

Remember to link the last node's next pointer back 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 30. This is the value of the node you want to delete from the circular linked list.

DSA C

#include 
#include 

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

int main() {
    Node* head = (Node*)malloc(sizeof(Node));
    Node* second = (Node*)malloc(sizeof(Node));
    Node* third = (Node*)malloc(sizeof(Node));
    Node* fourth = (Node*)malloc(sizeof(Node));
    Node* fifth = (Node*)malloc(sizeof(Node));

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = fourth;

    fourth->data = 40;
    fourth->next = fifth;

    fifth->data = 50;
    fifth->next = head; // circular link

    // Create an integer variable called target and set it to 30
    // Your code here

    return 0;
}

Hint

Just declare an integer variable named target and assign it the value 30.

3

Write the Function to Delete the Target Node

Write a function called deleteNode that takes two arguments: a pointer to the head node Node* head and an integer target. The function should delete the node with data equal to target from the circular linked list and return the new head pointer. Use this function in main to delete the node with value target.

DSA C

#include 
#include 

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

Node* deleteNode(Node* head, int target) {
    // Your code here
}

int main() {
    Node* head = (Node*)malloc(sizeof(Node));
    Node* second = (Node*)malloc(sizeof(Node));
    Node* third = (Node*)malloc(sizeof(Node));
    Node* fourth = (Node*)malloc(sizeof(Node));
    Node* fifth = (Node*)malloc(sizeof(Node));

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = fourth;

    fourth->data = 40;
    fourth->next = fifth;

    fifth->data = 50;
    fifth->next = head; // circular link

    int target = 30;

    head = deleteNode(head, target);

    return 0;
}

Hint

Handle deleting the head node separately. For other nodes, traverse the list to find the target and remove it by adjusting pointers.

4

Print the Circular Linked List After Deletion

Write a loop to print the circular linked list starting from head. Print each node's data followed by ->. After printing all nodes, print (back to head) to show the circular nature.

DSA C

#include 
#include 

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

Node* deleteNode(Node* head, int target) {
    if (head == NULL) return NULL;

    Node *curr = head, *prev = NULL;

    if (head->data == target && head->next == head) {
        free(head);
        return NULL;
    }

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

    prev = head;
    curr = head->next;
    while (curr != head) {
        if (curr->data == target) {
            prev->next = curr->next;
            free(curr);
            return head;
        }
        prev = curr;
        curr = curr->next;
    }

    return head;
}

int main() {
    Node* head = (Node*)malloc(sizeof(Node));
    Node* second = (Node*)malloc(sizeof(Node));
    Node* third = (Node*)malloc(sizeof(Node));
    Node* fourth = (Node*)malloc(sizeof(Node));
    Node* fifth = (Node*)malloc(sizeof(Node));

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = fourth;

    fourth->data = 40;
    fourth->next = fifth;

    fifth->data = 50;
    fifth->next = head; // circular link

    int target = 30;

    head = deleteNode(head, target);

    // Print the circular linked list starting from head
    // Your code here

    return 0;
}

Hint

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