Related Articles

# Deletion from a Circular Linked List

• Difficulty Level : Easy
• Last Updated : 27 Jul, 2021

We have already discussed circular linked list and traversal in a circular linked list in the below articles:
Traversal in a circular linked list We will be given a node and our task is to delete that node from the circular linked list.

Examples:

```Input : 2->5->7->8->10->(head node)
data = 5

7

Algorithm
Case 1: List is empty.

• If the list is empty we will simply return.

Case 2:List is not empty

• If the list is not empty then we define two pointers curr and prev and initialize the pointer curr with the head node.
• Traverse the list using curr to find the node to be deleted and before moving to curr to the next node, every time set prev = curr.
• If the node is found, check if it is the only node in the list. If yes, set head = NULL and free(curr).
• If the list has more than one node, check if it is the first node of the list. Condition to check this( curr == head). If yes, then move prev until it reaches the last node. After prev reaches the last node, set head = head -> next and prev -> next = head. Delete curr.
• If curr is not the first node, we check if it is the last node in the list. Condition to check this is (curr -> next == head).
• If curr is the last node. Set prev -> next = head and delete the node curr by free(curr).
• If the node to be deleted is neither the first node nor the last node, then set prev -> next = curr -> next and delete curr.

Complete program to demonstrate deletion in Circular Linked List:

## C++14

 `// C++ program to delete a given key from``// linked list.``#include ``using` `namespace` `std;` `/* structure for a node */``class` `Node {``public``:``    ``int` `data;``    ``Node* next;``};` `/* Function to insert a node at the beginning of``a Circular linked list */``void` `push(Node** head_ref, ``int` `data)``{``    ``// Create a new node and make head as next``    ``// of it.``    ``Node* ptr1 = ``new` `Node();``    ``ptr1->data = data;``    ``ptr1->next = *head_ref;` `    ``/* If linked list is not NULL then set the``    ``next of last node */``    ``if` `(*head_ref != NULL)``    ``{``        ``// Find the node before head and update``        ``// next of it.``        ``Node* temp = *head_ref;``        ``while` `(temp->next != *head_ref)``            ``temp = temp->next;``        ``temp->next = ptr1;``    ``}``    ``else``        ``ptr1->next = ptr1; ``/*For the first node */` `    ``*head_ref = ptr1;``}` `/* Function to print nodes in a given``circular linked list */``void` `printList(Node* head)``{``    ``Node* temp = head;``    ``if` `(head != NULL) {``        ``do` `{``            ``cout << temp->data << ``" "``;``            ``temp = temp->next;``        ``} ``while` `(temp != head);``    ``}` `    ``cout << endl;``}` `/* Function to delete a given node from the list */``void` `deleteNode(Node** head, ``int` `key)``{``    ` `    ``// If linked list is empty``    ``if` `(*head == NULL)``        ``return``;``        ` `    ``// If the list contains only a single node``    ``if``((*head)->data==key && (*head)->next==*head)``    ``{``        ``free``(*head);``        ``*head=NULL;``        ``return``;``    ``}``    ` `    ``Node *last=*head,*d;``    ` `    ``// If head is to be deleted``    ``if``((*head)->data==key)``    ``{``        ` `        ``// Find the last node of the list``        ``while``(last->next!=*head)``            ``last=last->next;``            ` `        ``// Point last node to the next of head i.e.``        ``// the second node of the list``        ``last->next=(*head)->next;``        ``free``(*head);``        ``*head=last->next;``    ``}``    ` `    ``// Either the node to be deleted is not found``    ``// or the end of list is not reached``    ``while``(last->next!=*head&&last->next->data!=key)``    ``{``        ``last=last->next;``    ``}``    ` `    ``// If node to be deleted was found``    ``if``(last->next->data==key)``    ``{``        ``d=last->next;``        ``last->next=d->next;``        ``free``(d);``    ``}``    ``else``        ``cout<<``"no such keyfound"``;``    ``}` `/* Driver code */``int` `main()``{``    ``/* Initialize lists as empty */``    ``Node* head = NULL;` `    ``/* Created linked list will be 2->5->7->8->10 */``    ``push(&head, 2);``    ``push(&head, 5);``    ``push(&head, 7);``    ``push(&head, 8);``    ``push(&head, 10);` `    ``cout << ``"List Before Deletion: "``;``    ``printList(head);` `    ``deleteNode(&head, 7);` `    ``cout << ``"List After Deletion: "``;``    ``printList(head);` `    ``return` `0;``}` `// This is code is contributed by rathbhupendra`

## C

 `// C program to delete a given key from``// linked list.``#include ``#include ` `/* structure for a node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `/* Function to insert a node at the beginning of``   ``a Circular linked list */``void` `push(``struct` `Node** head_ref, ``int` `data)``{``    ``// Create a new node and make head as next``    ``// of it.``    ``struct` `Node* ptr1 = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``    ``ptr1->data = data;``    ``ptr1->next = *head_ref;` `    ``/* If linked list is not NULL then set the``       ``next of last node */``    ``if` `(*head_ref != NULL) {``        ``// Find the node before head and update``        ``// next of it.``        ``struct` `Node* temp = *head_ref;``        ``while` `(temp->next != *head_ref)``            ``temp = temp->next;``        ``temp->next = ptr1;``    ``}``    ``else``        ``ptr1->next = ptr1; ``/*For the first node */` `    ``*head_ref = ptr1;``}` `/* Function to print nodes in a given``  ``circular linked list */``void` `printList(``struct` `Node* head)``{``    ``struct` `Node* temp = head;``    ``if` `(head != NULL) {``        ``do` `{``            ``printf``(``"%d "``, temp->data);``            ``temp = temp->next;``        ``} ``while` `(temp != head);``    ``}` `    ``printf``(``"\n"``);``}` `/* Function to delete a given node from the list */``void` `deleteNode(``struct` `Node* head, ``int` `key)``{``    ``if` `(head == NULL)``        ``return``;` `    ``// Find the required node``    ``struct` `Node *curr = head, *prev;``    ``while` `(curr->data != key)``    ``{``        ``if` `(curr->next == head)``        ``{``            ``printf``(``"\nGiven node is not found"``                   ``" in the list!!!"``);``            ``break``;``        ``}` `        ``prev = curr;``        ``curr = curr->next;``    ``}` `    ``// Check if node is only node``    ``if` `(curr->next == head)``    ``{``        ``head = NULL;``        ``free``(curr);``        ``return``;``    ``}` `    ``// If more than one node, check if``    ``// it is first node``    ``if` `(curr == head)``    ``{``        ``prev = head;``        ``while` `(prev->next != head)``            ``prev = prev->next;``        ``head = curr->next;``        ``prev->next = head;``        ``free``(curr);``    ``}` `    ``// check if node is last node``    ``else` `if` `(curr->next == head && curr == head)``    ``{``        ``prev->next = head;``        ``free``(curr);``    ``}``    ``else``    ``{``        ``prev->next = curr->next;``        ``free``(curr);``    ``}``}` `/* Driver code */``int` `main()``{``    ``/* Initialize lists as empty */``    ``struct` `Node* head = NULL;` `    ``/* Created linked list will be 2->5->7->8->10 */``    ``push(&head, 2);``    ``push(&head, 5);``    ``push(&head, 7);``    ``push(&head, 8);``    ``push(&head, 10);` `    ``printf``(``"List Before Deletion: "``);``    ``printList(head);` `    ``deleteNode(head, 7);` `    ``printf``(``"List After Deletion: "``);``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to delete a given key from``// linked list.``class` `GFG {` `    ``/* ure for a node */``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;``    ``};` `    ``/* Function to insert a node at the beginning of``a Circular linked list */``    ``static` `Node push(Node head_ref, ``int` `data)``    ``{``        ``// Create a new node and make head as next``        ``// of it.``        ``Node ptr1 = ``new` `Node();``        ``ptr1.data = data;``        ``ptr1.next = head_ref;` `        ``/* If linked list is not null then set the``    ``next of last node */``        ``if` `(head_ref != ``null``) {``            ``// Find the node before head and update``            ``// next of it.``            ``Node temp = head_ref;``            ``while` `(temp.next != head_ref)``                ``temp = temp.next;``            ``temp.next = ptr1;``        ``}``        ``else``            ``ptr1.next = ptr1; ``/*For the first node */` `        ``head_ref = ptr1;``        ``return` `head_ref;``    ``}` `    ``/* Function to print nodes in a given``circular linked list */``    ``static` `void` `printList(Node head)``    ``{``        ``Node temp = head;``        ``if` `(head != ``null``) {``            ``do` `{``                ``System.out.printf(``"%d "``, temp.data);``                ``temp = temp.next;``            ``} ``while` `(temp != head);``        ``}` `        ``System.out.printf(``"\n"``);``    ``}` `    ``/* Function to delete a given node from the list */``    ``static` `Node deleteNode(Node head, ``int` `key)``    ``{``        ``if` `(head == ``null``)``            ``return` `null``;` `        ``// Find the required node``        ``Node curr = head, prev = ``new` `Node();``        ``while` `(curr.data != key) {``            ``if` `(curr.next == head) {``                ``System.out.printf(``"\nGiven node is not found"``                                  ``+ ``" in the list!!!"``);``                ``break``;``            ``}` `            ``prev = curr;``            ``curr = curr.next;``        ``}` `        ``// Check if node is only node``        ``if` `(curr == head && curr.next == head) {``            ``head = ``null``;``            ``return` `head;``        ``}` `        ``// If more than one node, check if``        ``// it is first node``        ``if` `(curr == head) {``            ``prev = head;``            ``while` `(prev.next != head)``                ``prev = prev.next;``            ``head = curr.next;``            ``prev.next = head;``        ``}` `        ``// check if node is last node``        ``else` `if` `(curr.next == head) {``            ``prev.next = head;``        ``}``        ``else` `{``            ``prev.next = curr.next;``        ``}``        ``return` `head;``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `main(String args[])``    ``{``        ``/* Initialize lists as empty */``        ``Node head = ``null``;` `        ``/* Created linked list will be 2.5.7.8.10 */``        ``head = push(head, ``2``);``        ``head = push(head, ``5``);``        ``head = push(head, ``7``);``        ``head = push(head, ``8``);``        ``head = push(head, ``10``);` `        ``System.out.printf(``"List Before Deletion: "``);``        ``printList(head);` `        ``head = deleteNode(head, ``7``);` `        ``System.out.printf(``"List After Deletion: "``);``        ``printList(head);``    ``}``}` `// This code is contributed by Arnab Kundu`

## Python

 `# Python program to delete a given key from``# linked list.` `# Node of a doubly linked list``class` `Node:``    ``def` `__init__(``self``, ``next` `=` `None``, data ``=` `None``):``        ``self``.``next` `=` `next``        ``self``.data ``=` `data` `# Function to insert a node at the beginning of``# a Circular linked list``def` `push(head_ref, data):` `    ``# Create a new node and make head as next``    ``# of it.``    ``ptr1 ``=` `Node()``    ``ptr1.data ``=` `data``    ``ptr1.``next` `=` `head_ref` `    ``# If linked list is not None then set the``    ``# next of last node``    ``if` `(head_ref !``=` `None``) :``        ` `        ``# Find the node before head and update``        ``# next of it.``        ``temp ``=` `head_ref``        ``while` `(temp.``next` `!``=` `head_ref):``            ``temp ``=` `temp.``next``        ``temp.``next` `=` `ptr1``    ` `    ``else``:``        ``ptr1.``next` `=` `ptr1 ``# For the first node` `    ``head_ref ``=` `ptr1``    ``return` `head_ref` `# Function to print nodes in a given``# circular linked list``def` `printList( head):` `    ``temp ``=` `head``    ``if` `(head !``=` `None``) :``        ``while``(``True``) :``            ``print``( temp.data, end ``=` `" "``)``            ``temp ``=` `temp.``next``            ``if` `(temp ``=``=` `head):``                ``break``    ``print``()` `# Function to delete a given node from the list``def` `deleteNode( head, key) :` `    ``# If linked list is empty``    ``if` `(head ``=``=` `None``):``        ``return``        ` `    ``# If the list contains only a single node``    ``if``((head).data ``=``=` `key ``and` `(head).``next` `=``=` `head):``    ` `        ``head ``=` `None``    ` `    ``last ``=` `head``    ``d ``=` `None``    ` `    ``# If head is to be deleted``    ``if``((head).data ``=``=` `key) :``        ` `        ``# Find the last node of the list``        ``while``(last.``next` `!``=` `head):``            ``last ``=` `last.``next``            ` `        ``# Point last node to the next of head i.e.``        ``# the second node of the list``        ``last.``next` `=` `(head).``next``        ``head ``=` `last.``next``    ` `    ``# Either the node to be deleted is not found``    ``# or the end of list is not reached``    ``while``(last.``next` `!``=` `head ``and` `last.``next``.data !``=` `key) :``        ``last ``=` `last.``next` `    ``# If node to be deleted was found``    ``if``(last.``next``.data ``=``=` `key) :``        ``d ``=` `last.``next``        ``last.``next` `=` `d.``next``    ` `    ``else``:``        ``print``(``"no such keyfound"``)``    ` `    ``return` `head` `# Driver code` `# Initialize lists as empty``head ``=` `None` `# Created linked list will be 2.5.7.8.10``head ``=` `push(head, ``2``)``head ``=` `push(head, ``5``)``head ``=` `push(head, ``7``)``head ``=` `push(head, ``8``)``head ``=` `push(head, ``10``)` `print``(``"List Before Deletion: "``)``printList(head)` `head ``=` `deleteNode(head, ``7``)` `print``( ``"List After Deletion: "``)``printList(head)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# program to delete a given key from``// linked list.``using` `System;` `class` `GFG {` `    ``/* structure for a node */``    ``public` `class` `Node {``        ``public` `int` `data;``        ``public` `Node next;``    ``};` `    ``/* Function to insert a node at the beginning of``a Circular linked list */``    ``static` `Node push(Node head_ref, ``int` `data)``    ``{``        ``// Create a new node and make head as next``        ``// of it.``        ``Node ptr1 = ``new` `Node();``        ``ptr1.data = data;``        ``ptr1.next = head_ref;` `        ``/* If linked list is not null then set the``         ``next of last node */``        ``if` `(head_ref != ``null``)``        ``{``            ``// Find the node before head and update``            ``// next of it.``            ``Node temp = head_ref;``            ``while` `(temp.next != head_ref)``                ``temp = temp.next;``            ``temp.next = ptr1;``        ``}``        ``else``            ``ptr1.next = ptr1; ``/*For the first node */` `        ``head_ref = ptr1;``        ``return` `head_ref;``    ``}` `    ``/* Function to print nodes in a given``       ``circular linked list */``    ``static` `void` `printList(Node head)``    ``{``        ``Node temp = head;``        ``if` `(head != ``null``)``        ``{``            ``do``            ``{``                ``Console.Write(``"{0} "``, temp.data);``                ``temp = temp.next;``            ``} ``while` `(temp != head);``        ``}` `        ``Console.Write(``"\n"``);``    ``}` `    ``/* Function to delete a given node from the list */``    ``static` `Node deleteNode(Node head, ``int` `key)``    ``{``        ``if` `(head == ``null``)``            ``return` `null``;` `        ``// Find the required node``        ``Node curr = head, prev = ``new` `Node();``        ``while` `(curr.data != key)``        ``{``            ``if` `(curr.next == head)``            ``{``                ``Console.Write(``"\nGiven node is not found"``                              ``+ ``" in the list!!!"``);``                ``break``;``            ``}` `            ``prev = curr;``            ``curr = curr.next;``        ``}` `        ``// Check if node is only node``        ``if` `(curr.next == head && curr == head)``        ``{``            ``head = ``null``;``            ``return` `head;``        ``}` `        ``// If more than one node, check if``        ``// it is first node``        ``if` `(curr == head)``        ``{``            ``prev = head;``            ``while` `(prev.next != head)``                ``prev = prev.next;``            ``head = curr.next;``            ``prev.next = head;``        ``}` `        ``// check if node is last node``        ``else` `if` `(curr.next == head)``        ``{``            ``prev.next = head;``        ``}``        ``else``        ``{``            ``prev.next = curr.next;``        ``}``        ``return` `head;``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``/* Initialize lists as empty */``        ``Node head = ``null``;` `        ``/* Created linked list will be 2.5.7.8.10 */``        ``head = push(head, 2);``        ``head = push(head, 5);``        ``head = push(head, 7);``        ``head = push(head, 8);``        ``head = push(head, 10);` `        ``Console.Write(``"List Before Deletion: "``);``        ``printList(head);` `        ``head = deleteNode(head, 7);` `        ``Console.Write(``"List After Deletion: "``);``        ``printList(head);``    ``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output

```List Before Deletion: 10 8 7 5 2
List After Deletion: 10 8 5 2```

This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.