Remove Nth Node From End of List - Practice Coding Problems

Remove Nth Node From End of List - Problem

You're given the head of a singly linked list and need to remove the nth node from the end of the list, then return the modified list's head.

This is a classic linked list manipulation problem that tests your understanding of pointer arithmetic and list traversal techniques. The challenge lies in efficiently locating the nth node from the end without knowing the total length beforehand.

Key Points:

The list is 1-indexed from the end
You must handle edge cases like removing the head node
The solution should work in a single pass for optimal efficiency

Example: If you have [1,2,3,4,5] and n=2, you should remove the 2nd node from the end (value 4), returning [1,2,3,5].

Input & Output

example_1.py — Basic Removal

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

› Output: [1,2,3,5]

💡 Note: Remove the 2nd node from the end (node with value 4). The resulting list becomes [1,2,3,5].

example_2.py — Single Node

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

› Output: []

💡 Note: Removing the only node from the list results in an empty list.

example_3.py — Remove Head

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

› Output: [2]

💡 Note: Remove the 2nd node from the end, which is the head node (1). The list becomes [2].

Visualization

Tap to expand

Understanding the Visualization

Create the Window

Position two pointers with exactly the right gap between them

Slide the Window

Move both pointers together, maintaining the gap

Perfect Positioning

When the front reaches the end, the back is exactly where we need it

Execute Removal

Remove the target node with a simple pointer update

Key Takeaway

🎯 Key Insight: The two-pointer technique with a fixed gap transforms a two-pass problem into an elegant single-pass solution. This pattern is fundamental to many linked list problems.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list, visiting each node only once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and one dummy node, constant space

✓ Linear Space

Constraints

The number of nodes in the list is sz
1 ≤ sz ≤ 30
0 ≤ Node.val ≤ 100
1 ≤ n ≤ sz (n is always valid)

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The optimal solution uses the two-pointer technique with a clever gap strategy. By maintaining exactly n+1 nodes between fast and slow pointers, when the fast pointer reaches the end, the slow pointer is perfectly positioned to remove the target node in O(n) time and O(1) space. The dummy node elegantly handles edge cases like removing the head node.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (One Pass - Optimal)	O(n)	O(1)	Use fast and slow pointers with n-node gap for single-pass removal
Brute Force (Two Pass - Count Then Remove)	O(n)	O(1)	Count total nodes first, then traverse again to remove target node

Two Pointers (One Pass - Optimal) — Algorithm Steps

Create a dummy node pointing to head (handles edge cases)
Initialize two pointers: fast and slow both start at dummy
Move fast pointer n+1 steps ahead to create proper gap
Move both pointers together until fast reaches the end
Slow pointer is now at the node before target - remove target
Return dummy.next (the actual head)

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Dummy & Pointers

Create dummy node, initialize fast and slow pointers at dummy

Create Gap

Move fast pointer n+1 steps ahead (gap = 3 for n=2)

Move Together

Move both pointers together until fast reaches end

Remove Target

Slow pointer is at perfect position to remove target node

Code -

solution.c — C

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

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    // Create dummy node to handle edge cases
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    
    // Initialize two pointers
    struct ListNode* fast = dummy;
    struct ListNode* slow = dummy;
    
    // Move fast pointer n+1 steps ahead
    for (int i = 0; i <= n; i++) {
        fast = fast->next;
    }
    
    // Move both pointers until fast reaches end
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    
    // Remove the target node
    slow->next = slow->next->next;
    
    return dummy->next;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list, visiting each node only once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and one dummy node, constant space

✓ Linear Space

Constraints

The number of nodes in the list is sz
1 ≤ sz ≤ 30
0 ≤ Node.val ≤ 100
1 ≤ n ≤ sz (n is always valid)

128.4K Views

Very High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (One Pass - Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler