Delete N nodes after M nodes of a linked list (original) (raw)

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.

Try It Yourself

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

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

C#

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

`

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