Skip to content
Related Articles

Related Articles

Delete N nodes after M nodes of a linked list

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 03 Jul, 2022
Improve Article
Save Article

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

Complete Interview Preparation - GFG

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 off 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 off 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 off 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 off 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 off 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)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!