# Deletion from a Circular Linked List

• Difficulty Level : Easy
• Last Updated : 23 Nov, 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 Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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;``      ``return``;``    ``}``    ` `    ``// 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.