# Remove every k-th node of the linked list

Examples:

```Input : 1->2->3->4->5->6->7->8
k = 3
Output : 1->2->4->5->7->8
As 3 is the k-th node after its deletion list
would be 1->2->4->5->6->7->8
And now 4 is the starting node then from it, 6
would be the k-th node. So no other kth node
could be there.So, final list is:
1->2->4->5->7->8.

Input: 1->2->3->4->5->6
k = 1
Output: Empty list
All nodes need to be deleted
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The idea is traverse the list from beginning and keep track of nodes visited after last deletion. Whenever count becomes k, delete current node and reset count as 0.

```(1) Traverse list and do following
(a) Count node before deletion.
(b) If (count == k) that means current
node is to be deleted.
(i)  Delete current node i.e. do

//  assign address of next node of
// current node to the previous node
// of the current node.
prev->next = ptr->next i.e.

(ii) Reset count as 0, i.e., do count = 0.
(c) Update prev node if count != 0 and if
count is 0 that means that node is a
starting point.
(d) Update ptr and continue until all
k-th node gets deleted.
```

Below is C++ implementation.

```// C++ program to delete every k-th Node of
#include<iostream>
using namespace std;

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

// To remove complete list (Needed for
// case when k is 1)
void freeList(Node *node)
{
while (node != NULL)
{
Node *next = node->next;
delete (node);
node  = next;
}
}

// Deletes every k-th node and returns head
// of modified list.
Node *deleteKthNode(struct Node *head, int k)
{
// If linked list is empty
return NULL;

if (k == 1)
{
return NULL;
}

// Initialize ptr and prev before starting
// traversal.
struct Node *ptr = head, *prev = NULL;

// Traverse list and delete every k-th node
int count = 0;
while (ptr != NULL)
{
// increment Node count
count++;

// check if count is equal to k
// if yes, then delete current Node
if (k == count)
{
// put the next of current Node in
// the next of previous Node
delete(prev->next);
prev->next = ptr->next;

// set count = 0 to reach further
// k-th Node
count = 0;
}

// update prev if count is not 0
if (count != 0)
prev = ptr;

ptr = prev->next;
}

}

/* Function to print linked list */
{
while (temp != NULL)
{
cout<<temp->data<<" ";
temp = temp->next;
}
}

// Utility function to create a new node.
struct Node *newNode(int x)
{
Node *temp = new Node;
temp->data = x;
temp->next = NULL;
return temp;
}

/* Driver program to test count function*/
int main()
{
newNode(7);
newNode(8);

int k = 3;

return 0;
}
```

Output:

```1 2 4 5 7 8
```

Time Complexity : O(n)

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

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
1.5 Average Difficulty : 1.5/5.0
Based on 9 vote(s)