# Delete every Kth node from circular linked list

• Difficulty Level : Easy
• Last Updated : 26 Oct, 2021

Delete every kth node from a circular linked list until only one node is left. Also, print the intermediate lists.

Examples:

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.

```Input : n=4, k=2, list = 1->2->3->4
Output :
1->2->3->4->1
1->2->4->1
2->4->2
2->2

Input : n=9, k=4, list = 1->2->3->4->5->6->7->8->9
Output :
1->2->3->4->5->6->7->8->9->1
1->2->3->4->6->7->8->9->1
1->2->3->4->6->7->8->1
1->2->3->6->7->8->1
2->3->6->7->8->2
2->3->6->8->2
2->3->8->2
2->3->2
2->2```

Algorithm
Repeat the following steps until there is only one node left in the list.
Case 1: The list is empty.
If the list is empty, simply return it.
Case 2: The list has only one node.
If the list has only one node left, we will print the list and return it as our goal is reached.
Case 3: List has more than one node.
Define two pointers curr and prev and initialize the pointer curr with the head node.
Traverse the list using curr pointer by iterating it k times.

• The node to be deleted is the first node of the list.
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.
• The node to be deleted is the last node in the list.
The condition to check this is (curr -> next == head).
If curr is the last node. Set prev -> next = head and delete the node curr for free(curr).
• The one to be deleted is neither the first node nor the last node, then set prev -> next = temp -> next and delete curr.

## C++

 `// C++ program to delete every kth Node from``// circular linked list.``#include ``using` `namespace` `std;`` ` `/* structure for a Node */``struct` `Node {``    ``int` `data;``    ``Node* next;``    ``Node(``int` `x)``    ``{``        ``data = x;``        ``next = NULL;``    ``}``};`` ` `/*Utility function to print the circular linked list*/``void` `printList(Node* head)``{``    ``if` `(head == NULL)``        ``return``;``    ``Node* temp = head;``    ``do` `{``        ``cout << temp->data << ``"->"``;``        ``temp = temp->next;``    ``} ``while` `(temp != head);``    ``cout << head->data << endl;``}`` ` `/*Function to delete every kth Node*/``void` `deleteK(Node** head_ref, ``int` `k)``{``    ``Node* head = *head_ref;`` ` `    ``// If list is empty, simply return.``    ``if` `(head == NULL)``        ``return``;`` ` `    ``// take two pointers - current and previous``    ``Node *curr = head, *prev;``    ``while` `(``true``) {`` ` `        ``// Check if Node is the only Node\``        ``// If yes, we reached the goal, therefore ``        ``// return.``        ``if` `(curr->next == head && curr == head)``            ``break``;`` ` `        ``// Print intermediate list.``        ``printList(head);`` ` `        ``// If more than one Node present in the list,``        ``// Make previous pointer point to current``        ``// Iterate current pointer k times,``        ``// i.e. current Node is to be deleted.``        ``for` `(``int` `i = 0; i < k; i++) {``            ``prev = curr;``            ``curr = curr->next;``        ``}`` ` `        ``// If Node to be deleted is head``        ``if` `(curr == head) {``            ``prev = head;``            ``while` `(prev->next != head)``                ``prev = prev->next;``            ``head = curr->next;``            ``prev->next = head;``            ``*head_ref = head;``            ``free``(curr);``        ``}`` ` `        ``// If Node to be deleted is last Node.``        ``else` `if` `(curr->next == head) {``            ``prev->next = head;``            ``free``(curr);``        ``}``        ``else` `{``            ``prev->next = curr->next;``            ``free``(curr);``        ``}``    ``}``}`` ` `/* Function to insert a Node at the end of ``a Circular linked list */``void` `insertNode(Node** head_ref, ``int` `x)``{``    ``// Create a new Node``    ``Node* head = *head_ref;``    ``Node* temp = ``new` `Node(x);`` ` `    ``// if the list is empty, make the new Node head``    ``// Also, it will point to itself.``    ``if` `(head == NULL) {``        ``temp->next = temp;``        ``*head_ref = temp;``    ``}`` ` `    ``// traverse the list to reach the last Node ``    ``// and insert the Node``    ``else` `{``        ``Node* temp1 = head;``        ``while` `(temp1->next != head)``            ``temp1 = temp1->next;``        ``temp1->next = temp;``        ``temp->next = head;``    ``}``}`` ` `/* Driver program to test above functions */``int` `main()``{``    ``// insert Nodes in the circular linked list``    ``struct` `Node* head = NULL;``    ``insertNode(&head, 1);``    ``insertNode(&head, 2);``    ``insertNode(&head, 3);``    ``insertNode(&head, 4);``    ``insertNode(&head, 5);``    ``insertNode(&head, 6);``    ``insertNode(&head, 7);``    ``insertNode(&head, 8);``    ``insertNode(&head, 9);`` ` `    ``int` `k = 4;`` ` `    ``// Delete every kth Node from the``    ``// circular linked list.``    ``deleteK(&head, k);`` ` `    ``return` `0;``}`

## Java

 `// Java program to delete every kth Node from ``// circular linked list. ``class` `GFG``{``     ` `/* structure for a Node */``static` `class` `Node``{ ``    ``int` `data; ``    ``Node next; ``    ``Node(``int` `x) ``    ``{ ``        ``data = x; ``        ``next = ``null``; ``    ``} ``}; `` ` `/*Utility function to print ``the circular linked list*/``static` `void` `printList(Node head) ``{ ``    ``if` `(head == ``null``) ``        ``return``; ``    ``Node temp = head; ``    ``do` `    ``{ ``        ``System.out.print( temp.data + ``"->"``); ``        ``temp = temp.next; ``    ``} ``    ``while` `(temp != head); ``    ``System.out.println(head.data ); ``} `` ` `/*Function to delete every kth Node*/``static` `Node deleteK(Node head_ref, ``int` `k) ``{ ``    ``Node head = head_ref; `` ` `    ``// If list is empty, simply return. ``    ``if` `(head == ``null``) ``        ``return` `null``; `` ` `    ``// take two pointers - current and previous ``    ``Node curr = head, prev=``null``; ``    ``while` `(``true``) ``    ``{ `` ` `        ``// Check if Node is the only Node\ ``        ``// If yes, we reached the goal, therefore ``        ``// return. ``        ``if` `(curr.next == head && curr == head) ``            ``break``; `` ` `        ``// Print intermediate list. ``        ``printList(head); `` ` `        ``// If more than one Node present in the list, ``        ``// Make previous pointer point to current ``        ``// Iterate current pointer k times, ``        ``// i.e. current Node is to be deleted. ``        ``for` `(``int` `i = ``0``; i < k; i++) ``        ``{ ``            ``prev = curr; ``            ``curr = curr.next; ``        ``} `` ` `        ``// If Node to be deleted is head ``        ``if` `(curr == head) ``        ``{ ``            ``prev = head; ``            ``while` `(prev.next != head) ``                ``prev = prev.next; ``            ``head = curr.next; ``            ``prev.next = head; ``            ``head_ref = head; ``        ``} `` ` `        ``// If Node to be deleted is last Node. ``        ``else` `if` `(curr.next == head) ``        ``{ ``            ``prev.next = head; ``        ``} ``        ``else``        ``{ ``            ``prev.next = curr.next; ``        ``} ``    ``} ``    ``return` `head;``} `` ` `/* Function to insert a Node at the end of ``a Circular linked list */``static` `Node insertNode(Node head_ref, ``int` `x) ``{ ``    ``// Create a new Node ``    ``Node head = head_ref; ``    ``Node temp = ``new` `Node(x); `` ` `    ``// if the list is empty, make the new Node head ``    ``// Also, it will point to itself. ``    ``if` `(head == ``null``) ``    ``{ ``        ``temp.next = temp; ``        ``head_ref = temp; ``        ``return` `head_ref;``    ``} `` ` `    ``// traverse the list to reach the last Node ``    ``// and insert the Node ``    ``else` `    ``{ ``        ``Node temp1 = head; ``        ``while` `(temp1.next != head) ``            ``temp1 = temp1.next; ``        ``temp1.next = temp; ``        ``temp.next = head; ``    ``} ``    ``return` `head;``} `` ` `/* Driver code */``public` `static` `void` `main(String args[])``{ ``    ``// insert Nodes in the circular linked list ``    ``Node head = ``null``; ``    ``head = insertNode(head, ``1``); ``    ``head = insertNode(head, ``2``); ``    ``head = insertNode(head, ``3``); ``    ``head = insertNode(head, ``4``); ``    ``head = insertNode(head, ``5``); ``    ``head = insertNode(head, ``6``); ``    ``head = insertNode(head, ``7``); ``    ``head = insertNode(head, ``8``); ``    ``head = insertNode(head, ``9``); `` ` `    ``int` `k = ``4``; `` ` `    ``// Delete every kth Node from the ``    ``// circular linked list. ``    ``head = deleteK(head, k); ``} ``}`` ` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to delete every kth Node from``# circular linked list.``import` `math`` ` `# structure for a Node ``class` `Node: ``    ``def` `__init__(``self``, data): ``        ``self``.data ``=` `data ``        ``self``.``next` `=` `None`` ` `# Utility function to print the circular linked list``def` `prList(head):``    ``if` `(head ``=``=` `None``):``        ``return``    ``temp ``=` `head``     ` `    ``print``(temp.data, end ``=` `"->"``)``    ``temp ``=` `temp.``next``    ``while` `(temp !``=` `head):``        ``print``(temp.data, end ``=` `"->"``)``        ``temp ``=` `temp.``next``    ``print``(head.data)`` ` `# Function to delete every kth Node``def` `deleteK(head_ref, k):``    ``head ``=` `head_ref`` ` `    ``# If list is empty, simply return.``    ``if` `(head ``=``=` `None``):``        ``return`` ` `    ``# take two poers - current and previous``    ``curr ``=` `head``    ``prev ``=` `None``    ``while` `True``:`` ` `        ``# Check if Node is the only Node\``        ``# If yes, we reached the goal, therefore ``        ``# return.``        ``if` `(curr.``next` `=``=` `head ``and` `curr ``=``=` `head):``            ``break`` ` `        ``# Pr intermediate list.``        ``prList(head)`` ` `        ``# If more than one Node present in the list,``        ``# Make previous pointer po to current``        ``# Iterate current pointer k times,``        ``# i.e. current Node is to be deleted.``        ``for` `i ``in` `range``(k):``            ``prev ``=` `curr``            ``curr ``=` `curr.``next`` ` `        ``# If Node to be deleted is head``        ``if` `(curr ``=``=` `head):``            ``prev ``=` `head``            ``while` `(prev.``next` `!``=` `head):``                ``prev ``=` `prev.``next``            ``head ``=` `curr.``next``            ``prev.``next` `=` `head``            ``head_ref ``=` `head`` ` `        ``# If Node to be deleted is last Node.``        ``elif` `(curr.``next` `=``=` `head) :``            ``prev.``next` `=` `head``             ` `        ``else` `:``            ``prev.``next` `=` `curr.``next`` ` `# Function to insert a Node at the end of ``#a Circular linked list ``def` `insertNode(head_ref, x):``     ` `    ``# Create a new Node``    ``head ``=` `head_ref``    ``temp ``=` `Node(x)`` ` `    ``# if the list is empty, make the new Node head``    ``# Also, it will po to itself.``    ``if` `(head ``=``=` `None``):``        ``temp.``next` `=` `temp``        ``head_ref ``=` `temp``        ``return` `head_ref``     ` `    ``# traverse the list to reach the last Node ``    ``# and insert the Node``    ``else` `:``        ``temp1 ``=` `head``        ``while` `(temp1.``next` `!``=` `head):``            ``temp1 ``=` `temp1.``next``        ``temp1.``next` `=` `temp``        ``temp.``next` `=` `head``    ``return` `head`` ` `# Driver Code``if` `__name__``=``=``'__main__'``:``     ` `    ``# insert Nodes in the circular linked list``    ``head ``=` `None``    ``head ``=` `insertNode(head, ``1``) ``    ``head ``=` `insertNode(head, ``2``) ``    ``head ``=` `insertNode(head, ``3``) ``    ``head ``=` `insertNode(head, ``4``) ``    ``head ``=` `insertNode(head, ``5``) ``    ``head ``=` `insertNode(head, ``6``) ``    ``head ``=` `insertNode(head, ``7``) ``    ``head ``=` `insertNode(head, ``8``) ``    ``head ``=` `insertNode(head, ``9``) `` ` `    ``k ``=` `4`` ` `    ``# Delete every kth Node from the``    ``# circular linked list.``    ``deleteK(head, k)`` ` `# This code is contributed by Srathore`

## C#

 `// C# program to delete every kth Node from ``// circular linked list.``using` `System;`` ` `class` `GFG``{``     ` `/* structure for a Node */``public` `class` `Node``{ ``    ``public` `int` `data; ``    ``public` `Node next; ``    ``public` `Node(``int` `x) ``    ``{ ``        ``data = x; ``        ``next = ``null``; ``    ``} ``}; `` ` `/*Utility function to print ``the circular linked list*/``static` `void` `printList(Node head) ``{ ``    ``if` `(head == ``null``) ``        ``return``; ``    ``Node temp = head; ``    ``do``    ``{ ``        ``Console.Write( temp.data + ``"->"``); ``        ``temp = temp.next; ``    ``} ``    ``while` `(temp != head); ``    ``Console.WriteLine(head.data ); ``} `` ` `/*Function to delete every kth Node*/``static` `Node deleteK(Node head_ref, ``int` `k) ``{ ``    ``Node head = head_ref; `` ` `    ``// If list is empty, simply return. ``    ``if` `(head == ``null``) ``        ``return` `null``; `` ` `    ``// take two pointers - current and previous ``    ``Node curr = head, prev = ``null``; ``    ``while` `(``true``) ``    ``{ `` ` `        ``// Check if Node is the only Node\ ``        ``// If yes, we reached the goal, therefore ``        ``// return. ``        ``if` `(curr.next == head && curr == head) ``            ``break``; `` ` `        ``// Print intermediate list. ``        ``printList(head); `` ` `        ``// If more than one Node present in the list, ``        ``// Make previous pointer point to current ``        ``// Iterate current pointer k times, ``        ``// i.e. current Node is to be deleted. ``        ``for` `(``int` `i = 0; i < k; i++) ``        ``{ ``            ``prev = curr; ``            ``curr = curr.next; ``        ``} `` ` `        ``// If Node to be deleted is head ``        ``if` `(curr == head) ``        ``{ ``            ``prev = head; ``            ``while` `(prev.next != head) ``                ``prev = prev.next; ``            ``head = curr.next; ``            ``prev.next = head; ``            ``head_ref = head; ``        ``} `` ` `        ``// If Node to be deleted is last Node. ``        ``else` `if` `(curr.next == head) ``        ``{ ``            ``prev.next = head; ``        ``} ``        ``else``        ``{ ``            ``prev.next = curr.next; ``        ``} ``    ``} ``    ``return` `head;``} `` ` `/* Function to insert a Node at the end of ``a Circular linked list */``static` `Node insertNode(Node head_ref, ``int` `x) ``{ ``    ``// Create a new Node ``    ``Node head = head_ref; ``    ``Node temp = ``new` `Node(x); `` ` `    ``// if the list is empty, make the new Node head ``    ``// Also, it will point to itself. ``    ``if` `(head == ``null``) ``    ``{ ``        ``temp.next = temp; ``        ``head_ref = temp; ``        ``return` `head_ref;``    ``} `` ` `    ``// traverse the list to reach the last Node ``    ``// and insert the Node ``    ``else``    ``{ ``        ``Node temp1 = head; ``        ``while` `(temp1.next != head) ``            ``temp1 = temp1.next; ``        ``temp1.next = temp; ``        ``temp.next = head; ``    ``} ``    ``return` `head;``} `` ` `/* Driver code */``public` `static` `void` `Main(String []args)``{ ``    ``// insert Nodes in the circular linked list ``    ``Node head = ``null``; ``    ``head = insertNode(head, 1); ``    ``head = insertNode(head, 2); ``    ``head = insertNode(head, 3); ``    ``head = insertNode(head, 4); ``    ``head = insertNode(head, 5); ``    ``head = insertNode(head, 6); ``    ``head = insertNode(head, 7); ``    ``head = insertNode(head, 8); ``    ``head = insertNode(head, 9); `` ` `    ``int` `k = 4; `` ` `    ``// Delete every kth Node from the ``    ``// circular linked list. ``    ``head = deleteK(head, k); ``} ``}`` ` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``
Output:
```1->2->3->4->5->6->7->8->9->1
1->2->3->4->6->7->8->9->1
1->2->3->4->6->7->8->1
1->2->3->6->7->8->1
2->3->6->7->8->2
2->3->6->8->2
2->3->8->2
2->3->2
2->2```

My Personal Notes arrow_drop_up