Delete N Nodes After M Nodes of a Linked List

Delete N Nodes After M Nodes of a Linked List - Problem

Linked List Easy

You're given the head of a linked list and two integers m and n.

Your task: Traverse the linked list following a specific pattern - keep m nodes, then delete the next n nodes, and repeat this cycle until you reach the end.

Pattern:

Start from the head of the linked list
Keep the first m nodes
Remove the next n nodes
Repeat steps 2-3 until you reach the end

Example: If m=2 and n=3, you'll keep 2 nodes, delete 3 nodes, keep 2 nodes, delete 3 nodes, and so on.

Return the head of the modified linked list after all deletions.

Input & Output

example_1.py — Basic Pattern

$ Input: head = [1,2,3,4,5,6,7,8,9,10,11], m = 2, n = 3

› Output: [1,2,6,7,10,11]

💡 Note: Keep nodes 1,2 → Delete nodes 3,4,5 → Keep nodes 6,7 → Delete nodes 8,9,10 → Keep node 11. Note: We only delete 2 nodes (8,9) in the last cycle because node 10 doesn't exist in the delete phase.

example_2.py — Small List

$ Input: head = [1,2,3,4,5], m = 1, n = 2

› Output: [1,4]

💡 Note: Keep node 1 → Delete nodes 2,3 → Keep node 4 → Try to delete nodes 5,6 but only node 5 exists so delete it → Result: [1,4]

example_3.py — Edge Case

$ Input: head = [1,2], m = 1, n = 1

› Output: [1]

💡 Note: Keep node 1 → Delete node 2 → No more nodes left. Result: [1]

Constraints

The number of nodes in the list is in the range [1, 10⁴]
1 ≤ Node.val ≤ 1000
1 ≤ m, n ≤ 1000
Follow up: How would you solve this problem if you needed to minimize memory usage?

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the head of the train (linked list) with your m-keep, n-delete pattern rules

Keep Cars

Advance through m cars, keeping them connected for passengers

Disconnect Cars

Skip the next n cars by updating the connection to bypass them

Repeat Pattern

Continue this keep-delete cycle until you reach the end of the train

Key Takeaway

🎯 Key Insight: By maintaining a pointer to the last kept node and efficiently skipping unwanted nodes, we can solve this in a single pass with O(1) extra space, just like a conductor efficiently managing train cars.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Facebook 5

The optimal approach uses single-pass traversal with careful pointer manipulation. Keep track of the last node in each keep segment, then efficiently skip n nodes by updating the next pointer. This avoids complex state management while maintaining O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Pattern Matching	O(n)	O(1)	Traverse the list while carefully tracking the keep/delete pattern

Iterative Pattern Matching — Algorithm Steps

Initialize current pointer to head and set up counters
While current node exists, enter keep phase
Keep m nodes by advancing current pointer m times
Enter delete phase and remove next n nodes
Repeat until we reach the end of the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the complete linked list and identify the pattern parameters

Keep Phase

Traverse and keep the first m nodes

Delete Phase

Remove the next n nodes by updating pointers

Repeat Cycle

Continue the pattern until reaching the end

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* deleteNodes(struct ListNode* head, int m, int n) {
    if (!head || m == 0) return NULL;
    
    struct ListNode* current = head;
    
    while (current) {
        // Keep m nodes
        for (int i = 0; i < m - 1; i++) {
            if (current) current = current->next;
        }
        
        if (!current) break;
        
        // Delete n nodes
        for (int i = 0; i < n; i++) {
            if (current->next) {
                struct ListNode* temp = current->next;
                current->next = current->next->next;
                free(temp);
            } else {
                break;
            }
        }
        
        current = current->next;
    }
    
    return head;
}

int main() {
    // Parse input and call solution
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during traversal

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler