Delete every Kth node from circular linked list

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

Examples:

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. 
  Conditions to check this( curr == head && curr->next == 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.
• 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 <bits/stdc++.h>
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 printList(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 pointers - 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

        # 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 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

<script>
// javascript program to delete every kth Node from
// circular linked list.     /* structure for a Node */
    class Node {
        constructor(val) {
            this.data = val;
            this.next = null;
        }
    }

    /*
     * Utility function to print the circular linked list
     */
    function printList(head) {
        if (head == null)
            return;
        var temp = head;
        do {
            document.write(temp.data + "->");
            temp = temp.next;
        } while (temp != head);
        document.write(head.data+"<br/>");
    }

    /* Function to delete every kth Node */
    function deleteK(head_ref , k) {
        var head = head_ref;

        // If list is empty, simply return.
        if (head == null)
            return null;

        // take two pointers - current and previous
        var 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 (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
     */
    function insertNode(head_ref , x) {
        // Create a new Node
        var head = head_ref;
        var 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 {
            var temp1 = head;
            while (temp1.next != head)
                temp1 = temp1.next;
            temp1.next = temp;
            temp.next = head;
        }
        return head;
    }

    /* Driver code */

        // insert Nodes in the circular linked list
        var 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);

        var k = 4;

        // Delete every kth Node from the
        // circular linked list.
        head = deleteK(head, k);

// This code is contributed by todaysgaurav
</script>

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