Open In App
Related Articles

Delete N nodes after M nodes of a linked list

Improve Article
Improve
Save Article
Save
Like Article
Like

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
Linked List: 1->2->3->4->5->6->7->8
Output:
Linked List: 1->2->5->6

Input:
M = 3, N = 2
Linked List: 1->2->3->4->5->6->7->8->9->10
Output:
Linked List: 1->2->3->6->7->8

Input:
M = 1, N = 1
Linked List: 1->2->3->4->5->6->7->8->9->10
Output:
Linked List: 1->3->5->7->9

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 <bits/stdc++.h>
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<<temp->data<<" "
        temp = temp->next; 
    
    cout<<endl; 
  
// Function to skip M nodes and then
// delete N nodes of the linked list. 
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) 
    
        // 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; 
            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 <stdio.h>
#include <stdlib.h>
  
// 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; 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++)
        {
            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 =
  
# 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




<script>
  
// Javascript program to delete N nodes 
// after M nodes of a linked list 
  
    // A linked list node
class Node {
    constructor() {
        this.data = 0;
        this.next = null;
    }
}
  
    /* Function to insert a node at the beginning */
    function push(head_ref , new_data) {
        /* allocate node */
var 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 */
    function printList(head) {
var temp = head;
        while (temp != null) {
            document.write(temp.data+" ");
            temp = temp.next;
        }
        document.write("<br/>");
    }
  
    // Function to skip M nodes and then
    // delete N nodes of the linked list.
    function skipMdeleteN(head , M , N) {
var curr = head, t;
        var 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++)
            {
        var 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
      
        /*
          Create following linked list 
         1.2.3.4.5.6.7.8.9.10
         */
var head = null;
        var 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);
  
        document.write(
        "M = "+M+", N = "+N+"<br/>Given Linked list is :<br/>"
        );
        printList(head);
  
        skipMdeleteN(head, M, N);
  
        document.write(
        "<br/>Linked list after deletion is :<br/>"
        );
        printList(head);
  
// This code contributed by gauravrajput1
  
</script>


Output

M = 2 N = 3
Given Linked list is :
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)


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 10 Jan, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials