# Delete N nodes after M nodes of a linked list

Given a linked list and two integers M and N. Traverse the linked list such that you retain M nodes then delete next N nodes, continue the same till end of the linked list.
Difficulty Level: Rookie

Examples

```Input:
M = 2, N = 2
Output:

Input:
M = 3, N = 2
Output:

Input:
M = 1, N = 1
Output:

The main part of the problem is to maintain proper links between nodes, and make sure that all corner cases are handled. Following is C implementation of function skipMdeleteN() that skips M nodes and delete N nodes till end of list. It is assumed that M cannot be 0.

Implementation:

## C++

 `// C++ program to delete N nodes ``// after M nodes of a linked list  ``#include ``using` `namespace` `std; `` ` `// A linked list node  ``class` `Node  ``{  ``    ``public``: ``    ``int` `data;  ``    ``Node *next;  ``};  `` ` `/* Function to insert a node at the beginning */``void` `push(Node ** head_ref, ``int` `new_data)  ``{  ``    ``/* allocate node */``    ``Node* new_node = ``new` `Node(); `` ` `    ``/* put in the data */``    ``new_node->data = new_data;  `` ` `    ``/* link the old list of the new node */``    ``new_node->next = (*head_ref);  `` ` `    ``/* move the head to point to the new node */``    ``(*head_ref) = new_node;  ``}  `` ` `/* Function to print linked list */``void` `printList(Node *head)  ``{  ``    ``Node *temp = head;  ``    ``while` `(temp != NULL)  ``    ``{  ``        ``cout<data<<``" "``;  ``        ``temp = temp->next;  ``    ``}  ``    ``cout<next;  `` ` `        ``// If we reached end of list, then return  ``        ``if` `(curr == NULL)  ``            ``return``;  `` ` `        ``// Start from next node and delete N nodes  ``        ``t = curr->next;  ``        ``for` `(count = 1; count<=N && t!= NULL; count++)  ``        ``{  ``            ``Node *temp = t;  ``            ``t = t->next;  ``            ``free``(temp);  ``        ``}  ``         ` `        ``// Link the previous list with remaining nodes  ``        ``curr->next = t;  `` ` `        ``// Set current pointer for next iteration  ``        ``curr = t;  ``    ``}  ``}  `` ` `// Driver code  ``int` `main()  ``{  ``    ``/* Create following linked list  ``    ``1->2->3->4->5->6->7->8->9->10 */``    ``Node* head = NULL;  ``    ``int` `M=2, N=3;  ``    ``push(&head, 10);  ``    ``push(&head, 9);  ``    ``push(&head, 8);  ``    ``push(&head, 7);  ``    ``push(&head, 6);  ``    ``push(&head, 5);  ``    ``push(&head, 4);  ``    ``push(&head, 3);  ``    ``push(&head, 2);  ``    ``push(&head, 1);  `` ` `    ``cout << ``"M = "` `<< M<< ``" N = "` `<< N << ``"\nGiven Linked list is :\n"``;  ``    ``printList(head);  `` ` `    ``skipMdeleteN(head, M, N);  `` ` `    ``cout<<``"\nLinked list after deletion is :\n"``;  ``    ``printList(head);  `` ` `    ``return` `0;  ``}  `` ` `// This code is contributed by rathbhupendra `

## C

 `// C program to delete N nodes after M nodes of a linked list ``#include ``#include `` ` `// A linked list node ``struct` `Node ``{ ``    ``int` `data; ``    ``struct` `Node *next; ``}; `` ` `/* Function to insert a node at the beginning */``void` `push(``struct` `Node ** head_ref, ``int` `new_data) ``{ ``    ``/* allocate node */``    ``struct` `Node* new_node = (``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node)); `` ` `    ``/* put in the data  */``    ``new_node->data  = new_data; `` ` `    ``/* link the old list of the new node */``    ``new_node->next = (*head_ref); `` ` `    ``/* move the head to point to the new node */``    ``(*head_ref)  = new_node; ``} `` ` `/* Function to print linked list */``void` `printList(``struct` `Node *head) ``{ ``    ``struct` `Node *temp = head; ``    ``while` `(temp != NULL) ``    ``{ ``        ``printf``(``"%d "``, temp->data); ``        ``temp = temp->next; ``    ``} ``    ``printf``(``"\n"``); ``} `` ` `// Function to skip M nodes and then delete N nodes of the linked list. ``void` `skipMdeleteN(``struct` `Node  *head, ``int` `M, ``int` `N) ``{ ``    ``struct` `Node *curr = head, *t; ``    ``int` `count; `` ` `    ``// The main loop that traverses through the whole list ``    ``while` `(curr) ``    ``{ ``        ``// Skip M nodes ``        ``for` `(count = 1; countnext; `` ` `        ``// If we reached end of list, then return ``        ``if` `(curr == NULL) ``            ``return``; `` ` `        ``// Start from next node and delete N nodes ``        ``t = curr->next; ``        ``for` `(count = 1; count<=N && t!= NULL; count++) ``        ``{ ``            ``struct` `Node *temp = t; ``            ``t = t->next; ``            ``free``(temp); ``        ``} ``        ``curr->next = t; ``// Link the previous list with remaining nodes `` ` `        ``// Set current pointer for next iteration ``        ``curr = t; ``    ``} ``} `` ` `// Driver program to test above functions ``int` `main() ``{ ``    ``/* Create following linked list ``      ``1->2->3->4->5->6->7->8->9->10 */``    ``struct` `Node* head = NULL; ``    ``int` `M=2, N=3; ``    ``push(&head, 10); ``    ``push(&head, 9); ``    ``push(&head, 8); ``    ``push(&head, 7); ``    ``push(&head, 6); ``    ``push(&head, 5); ``    ``push(&head, 4); ``    ``push(&head, 3); ``    ``push(&head, 2); ``    ``push(&head, 1); `` ` `    ``printf``(``"M = %d, N = %d \nGiven Linked list is :\n"``, M, N); ``    ``printList(head); `` ` `    ``skipMdeleteN(head, M, N); `` ` `    ``printf``(``"\nLinked list after deletion is :\n"``); ``    ``printList(head); `` ` `    ``return` `0; ``} `

## Java

 `// Java program to delete N nodes  ``// after M nodes of a linked list  ``import` `java.util.*; `` ` `class` `GFG ``{ `` ` `// A linked list node  ``static` `class` `Node  ``{  ``    ``int` `data;  ``    ``Node next;  ``};  `` ` `/* Function to insert a node at the beginning */``static` `Node push( Node head_ref, ``int` `new_data)  ``{  ``    ``/* allocate node */``    ``Node new_node = ``new` `Node();  `` ` `    ``/* put in the data */``    ``new_node.data = new_data;  `` ` `    ``/* link the old list of the new node */``    ``new_node.next = (head_ref);  `` ` `    ``/* move the head to point to the new node */``    ``(head_ref) = new_node; ``     ` `    ``return` `head_ref; ``}  `` ` `/* Function to print linked list */``static` `void` `printList( Node head)  ``{  ``    ``Node temp = head;  ``    ``while` `(temp != ``null``)  ``    ``{  ``        ``System.out.printf(``"%d "``, temp.data);  ``        ``temp = temp.next;  ``    ``}  ``    ``System.out.printf(``"\n"``);  ``}  `` ` `// Function to skip M nodes and then ``// delete N nodes of the linked list.  ``static` `void` `skipMdeleteN( Node head, ``int` `M, ``int` `N)  ``{  ``    ``Node curr = head, t;  ``    ``int` `count;  `` ` `    ``// The main loop that traverses ``    ``// through the whole list  ``    ``while` `(curr!=``null``)  ``    ``{  ``        ``// Skip M nodes  ``        ``for` `(count = ``1``; count < M && curr != ``null``; count++)  ``            ``curr = curr.next;  `` ` `        ``// If we reached end of list, then return  ``        ``if` `(curr == ``null``)  ``            ``return``;  `` ` `        ``// Start from next node and delete N nodes  ``        ``t = curr.next;  ``        ``for` `(count = ``1``; count <= N && t != ``null``; count++)  ``        ``{  ``            ``Node temp = t;  ``            ``t = t.next;  ``        ``}  ``         ` `        ``// Link the previous list with remaining nodes  ``        ``curr.next = t;  `` ` `        ``// Set current pointer for next iteration  ``        ``curr = t;  ``    ``}  ``}  `` ` `// Driver code  ``public` `static` `void` `main(String args[]) ``{  ``    ``/* Create following linked list  ``    ``1.2.3.4.5.6.7.8.9.10 */``    ``Node head = ``null``;  ``    ``int` `M=``2``, N=``3``;  ``    ``head=push(head, ``10``);  ``    ``head=push(head, ``9``);  ``    ``head=push(head, ``8``);  ``    ``head=push(head, ``7``);  ``    ``head=push(head, ``6``);  ``    ``head=push(head, ``5``);  ``    ``head=push(head, ``4``);  ``    ``head=push(head, ``3``);  ``    ``head=push(head, ``2``);  ``    ``head=push(head, ``1``);  `` ` `    ``System.out.printf(``"M = %d, N = %d \nGiven"` `+  ``                        ``"Linked list is :\n"``, M, N);  ``    ``printList(head);  `` ` `    ``skipMdeleteN(head, M, N);  `` ` `    ``System.out.printf(``"\nLinked list after deletion is :\n"``);  ``    ``printList(head);  ``}  ``} `` ` `// This code is contributed by Arnab Kundu `

## Python3

 `# Python program to delete M nodes after N nodes `` ` `# Node class  ``class` `Node: `` ` `    ``# Constructor to initialize the node object ``    ``def` `__init__(``self``, data): ``        ``self``.data ``=` `data ``        ``self``.``next` `=` `None`` ` `class` `LinkedList: `` ` `    ``# Function to initialize head ``    ``def` `__init__(``self``): ``        ``self``.head ``=` `None`` ` `    ``# Function to insert a new node at the beginning ``    ``def` `push(``self``, new_data): ``        ``new_node ``=` `Node(new_data) ``        ``new_node.``next` `=` `self``.head ``        ``self``.head ``=` `new_node `` ` `    ``# Utility function to print the linked LinkedList ``    ``def` `printList(``self``): ``        ``temp ``=` `self``.head ``        ``while``(temp): ``            ``print` `(temp.data,end``=``" "``) ``            ``temp ``=` `temp.``next`` ` `    ``def` `skipMdeleteN(``self``, M, N): ``        ``curr ``=` `self``.head ``         ` `        ``# The main loop that traverses through the ``        ``# whole list ``        ``while``(curr): ``            ``# Skip M nodes ``            ``for` `count ``in` `range``(``1``, M): ``                ``if` `curr ``is` `None``: ``                    ``return` `                ``curr ``=` `curr.``next``                     ` `            ``if` `curr ``is` `None` `: ``                ``return` ` ` `            ``# Start from next node and delete N nodes ``            ``t ``=` `curr.``next` `            ``for` `count ``in` `range``(``1``, N``+``1``): ``                ``if` `t ``is` `None``: ``                    ``break``                ``t ``=` `t.``next``     ` `            ``# Link the previous list with remaining nodes ``            ``curr.``next` `=` `t ``            ``# Set Current pointer for next iteration ``            ``curr ``=` `t  `` ` `# Driver program to test above function `` ` `# Create following linked list ``# 1->2->3->4->5->6->7->8->9->10 ``llist ``=` `LinkedList() ``M ``=` `2` `N ``=` `3``llist.push(``10``) ``llist.push(``9``) ``llist.push(``8``) ``llist.push(``7``) ``llist.push(``6``) ``llist.push(``5``) ``llist.push(``4``) ``llist.push(``3``) ``llist.push(``2``) ``llist.push(``1``) `` ` `print` `(``"M = %d, N = %d\nGiven Linked List is:"` `%``(M, N)) ``llist.printList() ``print``() `` ` `llist.skipMdeleteN(M, N) `` ` `print` `(``"\nLinked list after deletion is"``) ``llist.printList() `` ` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007) `

## C#

 `// C# program to delete N nodes  ``// after M nodes of a linked list  ``using` `System; `` ` `class` `GFG  ``{  `` ` `// A linked list node  ``public` `class` `Node  ``{  ``    ``public` `int` `data;  ``    ``public` `Node next;  ``};  `` ` `/* Function to insert a node at the beginning */``static` `Node push( Node head_ref, ``int` `new_data)  ``{  ``    ``/* allocate node */``    ``Node new_node = ``new` `Node();  `` ` `    ``/* put in the data */``    ``new_node.data = new_data;  `` ` `    ``/* link the old list of the new node */``    ``new_node.next = (head_ref);  `` ` `    ``/* move the head to point to the new node */``    ``(head_ref) = new_node;  ``     ` `    ``return` `head_ref;  ``}  `` ` `/* Function to print linked list */``static` `void` `printList( Node head)  ``{  ``    ``Node temp = head;  ``    ``while` `(temp != ``null``)  ``    ``{  ``        ``Console.Write(``"{0} "``, temp.data);  ``        ``temp = temp.next;  ``    ``}  ``    ``Console.Write(``"\n"``);  ``}  `` ` `// Function to skip M nodes and then  ``// delete N nodes of the linked list.  ``static` `void` `skipMdeleteN( Node head, ``int` `M, ``int` `N)  ``{  ``    ``Node curr = head, t;  ``    ``int` `count;  `` ` `    ``// The main loop that traverses  ``    ``// through the whole list  ``    ``while` `(curr!=``null``)  ``    ``{  ``        ``// Skip M nodes  ``        ``for` `(count = 1; count < M &&  ``                ``curr != ``null``; count++)  ``            ``curr = curr.next;  `` ` `        ``// If we reached end of list, then return  ``        ``if` `(curr == ``null``)  ``            ``return``;  `` ` `        ``// Start from next node and delete N nodes  ``        ``t = curr.next;  ``        ``for` `(count = 1; count <= N && t != ``null``; count++)  ``        ``{  ``            ``Node temp = t;  ``            ``t = t.next;  ``        ``}  ``         ` `        ``// Link the previous list with remaining nodes  ``        ``curr.next = t;  `` ` `        ``// Set current pointer for next iteration  ``        ``curr = t;  ``    ``}  ``}  `` ` `// Driver code  ``public` `static` `void` `Main(String []args)  ``{  ``    ``/* Create following linked list  ``    ``1.2.3.4.5.6.7.8.9.10 */``    ``Node head = ``null``;  ``    ``int` `M=2, N=3;  ``    ``head=push(head, 10);  ``    ``head=push(head, 9);  ``    ``head=push(head, 8);  ``    ``head=push(head, 7);  ``    ``head=push(head, 6);  ``    ``head=push(head, 5);  ``    ``head=push(head, 4);  ``    ``head=push(head, 3);  ``    ``head=push(head, 2);  ``    ``head=push(head, 1);  `` ` `    ``Console.Write(``"M = {0}, N = {1} \nGiven"` `+  ``                        ``"Linked list is :\n"``, M, N);  ``    ``printList(head);  `` ` `    ``skipMdeleteN(head, M, N);  `` ` `    ``Console.Write(``"\nLinked list after deletion is :\n"``);  ``    ``printList(head);  ``}  ``}  `` ` `// This code contributed by Rajput-Ji `

## Javascript

 ` `

Output
```M = 2 N = 3
1 2 3 4 5 6 7 8 9 10

Linked list after deletion is :
1 2 6 7 ```

Time Complexity: O(n) where n is number of nodes in linked list.
Auxiliary Space: O(1)

Previous
Next