Delete N nodes after M nodes of a linked list

Last Updated : 11 Dec, 2024

Given a linked list and two integers m and n, the task is to traverse the linked list such that you skip m nodes, then delete the next n nodes, and continue the same till end of the linked list.

Note: m cannot be 0.

Example:

Input: Linked List: 9->1->3->5->9->4->10->1, n = 1, m = 2

Output: 9->1->5->9->10->1

Explanation: Deleting 1 node after skipping 2 nodes each time, we have list as 9-> 1-> 5-> 9-> 10-> 1.
Input: Linked List: 1->2->3->4->5->6, n = 1, m = 6

Output: 1->2->3->4->5->6

Explanation: After skipping 6 nodes for the first time , we will reach of end of the linked list, so, we will get the given linked list itself.

The idea is to go through a linked list and, for every set of nodes, keep the first m nodes and delete the next n nodes, and then repeat this process until the end of the list.

Step-by-step approach:

Start with a pointer at the first node (the head) of the linked list.
Move this pointer forward m times, so it skips over m nodes.
After skipping m nodes, the next n nodes should be deleted.
- To do this, we disconnect these n nodes from the list and free their memory.
After deleting the n nodes, repeat the process starting from the next node. Skip the next m nodes and delete the following n nodes.
This process will stops when we reach to end of the list, either because there are fewer than m nodes left to skip or there are no nodes left to delete.

Below is the implementation of the above approach:

C++

// C++ program to delete n nodes
// after m nodes of a linked list 

#include <bits/stdc++.h>
using namespace std;

class Node { 
public:
    int data; 
    Node *next; 
    Node(int x){
        data = x;
        next = nullptr;
    }
}; 

// Function to skip m nodes and then
// delete n nodes of the linked list. 
Node* skipMdeleteN(Node *head, int m, int n) { 
    Node *curr = head, *t; 

    // The main loop that traverses
    // through the whole list 
    while (curr != nullptr) { 
      
        // Skip m nodes 
        for (int i = 1; i < m && curr!= nullptr; i++) 
            curr = curr->next; 

        // If we reached end of list, then return 
        if (curr == nullptr) 
            return head; 

        // Start from next node and delete n nodes 
        t = curr->next; 
        for (int i = 1; i <= n && t!= nullptr; i++) { 
            Node *temp = t; 
            t = t->next; 
            delete(temp); 
        } 
        
        // Link the previous list with
      	// remaining nodes 
        curr->next = t; 

        // Set current pointer for next iteration 
        curr = t; 
    } 
	return head;
} 

void printList(Node *head) { 
    Node *curr = head; 
    while (curr != nullptr) { 
        cout<<curr->data<<" "; 
        curr = curr->next; 
    } 
    cout<<endl; 
} 

int main() { 
    // Create following linked list:
    // 1->2->3->4->5->6
    Node* head = new Node(1); 
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);
    head->next->next->next->next->next = new Node(6);

    int m = 2, n = 2; 
    head = skipMdeleteN(head, m, n); 
    printList(head); 

    return 0; 
}

// C program to delete n nodes after
// m nodes of a linked list

#include <stdio.h>
#include <stdlib.h>

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

// Function to skip m nodes and then delete n nodes of the linked list
struct Node *skipMdeleteN(struct Node *head, int m, int n){
    struct Node *curr = head; // Current node pointer
    struct Node *t;           // Temporary node pointer
    int count;                // Counter variable

    // Traverse through the entire linked list
    while (curr != NULL){
        // Skip m nodes
        for (count = 1; count < m && curr != NULL; count++)
            curr = curr->next;

        // If end of the list is reached, return the head
        if (curr == NULL)
            return head;

        // Start from the 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);
        }

        // Link the current node to the remaining list
        curr->next = t;

        // Move the current pointer to the next node
        curr = t;
    }

    return head;
}

void printList(struct Node *head){
    struct Node *curr = head;
    while (curr != NULL){
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

struct Node *createNode(int data){
    struct Node *temp = (struct Node *)malloc(sizeof(struct Node));
    temp->data = data;
    temp->next = NULL;
    return temp;
}

int main(){
    // Create the following linked list: 1->2->3->4->5->6
    struct Node *head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);
    head->next->next->next->next->next = createNode(6);

    int m = 2, n = 2;
    head = skipMdeleteN(head, m, n);
    printList(head);

    return 0;
}

Java

// Java program to delete n nodes
// after m nodes of a linked list

class Node {
    int data;
    Node next;

    Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

class GfG {

    // Function to skip m nodes and then delete n nodes
    // of the linked list
    static Node skipMdeleteN(Node head, int m, int n)
    {
        Node curr = head; // Current node pointer
        Node t; // Temporary node pointer
        int count; // Counter variable

        // Traverse through the entire linked list
        while (curr != null) {

            // Skip m nodes
            for (count = 1; count < m && curr != null;
                 count++)
                curr = curr.next;

            // If end of the list is reached, return the
            // head
            if (curr == null)
                return head;

            // Start from the next node and delete n nodes
            t = curr.next;
            for (count = 1; count <= n && t != null;
                 count++) {
                Node temp = t;
                t = t.next;

                // Dereference the node for garbage
                // collection
                temp = null;
            }

            // Link the current node to the remaining list
            curr.next = t;

            // Move the current pointer to the next node
            curr = t;
        }

        return head;
    }

    static void printList(Node head)
    {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        // Create the following linked list:
        // 1->2->3->4->5->6
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);
        head.next.next.next.next.next = new Node(6);

        int m = 2, n = 2;
        head = skipMdeleteN(head, m, n);
        printList(head);
    }
}

Python

# Python program to delete n nodes
# after m nodes of a linked list

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# Function to skip m nodes and then delete n nodes
# of the linked list
def skipMdeleteN(head, m, n):
    curr = head  # Current node pointer
    count = 0    # Counter variable

    # Traverse through the entire linked list
    while curr:

        # Skip m nodes
        for count in range(1, m):
            if curr is None:
                return head
            curr = curr.next

        # If end of the list is reached, return the head
        if curr is None:
            return head

        # Start from the next node and delete n nodes
        t = curr.next
        for count in range(1, n + 1):
            if t is None:
                break
            temp = t
            t = t.next
            del temp  # Delete the node

        # Link the current node to the remaining list
        curr.next = t

        # Move the current pointer to the next node
        curr = t

    return head

def printList(head):
    curr = head 
    while curr:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":
    # Create the following linked list: 1->2->3->4->5->6
    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)
    head.next.next.next.next.next = Node(6)

    m = 2
    n = 2
    head = skipMdeleteN(head, m, n)
    printList(head)

using System;

class Node {
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

class GfG {
    // Function to skip m nodes and then delete n nodes of
    // the linked list
    public static Node skipMdeleteN(Node head, int m, int n)
    {
        Node curr = head; // Current node pointer
        Node t; // Temporary node pointer
        int count; // Counter variable

        // Traverse through the entire linked list
        while (curr != null) {
            // Skip m nodes
            for (count = 1; count < m && curr != null;
                 count++)
                curr = curr.next;

            // If end of the list is reached, return the
            // head
            if (curr == null)
                return head;

            // Start from the next node and delete n nodes
            t = curr.next;
            for (count = 1; count <= n && t != null;
                 count++) {
                t = t.next; // Move to the next node
            }

            // Link the current node to the remaining list
            curr.next = t;

            // Move the current pointer to the next node
            curr = t;
        }

        return head;
    }

    static void printList(Node head)
    {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main()
    {
        // Create the following linked list:
        // 1->2->3->4->5->6
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);
        head.next.next.next.next.next = new Node(6);

        int m = 2, n = 2;
        head = skipMdeleteN(head, m, n);
        printList(head);
    }
}

JavaScript

// Javascript program to delete n nodes
// after m nodes of a linked list

class Node {
    constructor(data)
    {
        this.data = data;
        this.next = null;
    }
}

// Function to skip m nodes and then delete n nodes of the
// linked list
function skipMdeleteN(head, m, n)
{
    let curr = head; // Current node pointer
    let count = 0; // Counter variable

    // Traverse through the entire linked list
    while (curr !== null) {

        // Skip m nodes
        for (count = 1; count < m && curr !== null; count++)
            curr = curr.next;

        // If end of the list is reached, return the head
        if (curr === null)
            return head;

        // Start from the next node and delete n nodes
        let t = curr.next;
        for (count = 1; count <= n && t !== null; count++) {
            let temp = t;
            t = t.next;

            // Dereference the node
            temp = null;
        }

        // Link the current node to the remaining list
        curr.next = t;

        // Move the current pointer to the next node
        curr = t;
    }

    return head;
}

function printList(head)
{
    let curr = head;
    while (curr !== null) {
        process.stdout.write(curr.data + " ");
        curr = curr.next;
    }
    console.log();
}

// Create the following linked list: 1->2->3->4->5->6
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head.next.next.next.next.next = new Node(6);

let m = 2, n = 2;

// Perform the skip and delete operation
head = skipMdeleteN(head, m, n);

// Print the modified linked list
printList(head);

Output

1 2 5 6

Time Complexity: O(n), where n is the total number of nodes in the linked list. This is because the algorithm processes each node exactly once, either by skipping it or by deleting it.
Auxiliary Space: O(1)

Delete N nodes after M nodes of a linked list

kartik

Improve

Article Tags :

Practice Tags :

Delete N nodes after M nodes of a linked list

Similar Reads

Thank You!

What kind of Experience do you want to share?