Remove Nth Node From End of List

Remove Nth Node From End of List - Problem

Given the head of a linked list, remove the n-th node from the end of the list and return its head.

The list is 1-indexed from the end, meaning the last node is the 1st node from the end, the second-to-last is the 2nd node from the end, and so on.

Follow up: Could you do this in one pass?

Input & Output

Example 1 — Remove Middle Node

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

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

💡 Note: Remove the 2nd node from the end, which is node 4. The 2nd from end (n=2) is at position 4 (1-indexed), so we remove it and return [1,2,3,5].

Example 2 — Remove Head

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

› Output: []

💡 Note: There's only one node and we need to remove the 1st (and only) node from the end. Result is an empty list.

Example 3 — Remove Last Node

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

› Output: [1]

💡 Note: Remove the 1st node from end (which is the last node). Remove node 2 and return [1].

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 G Google 32 f Facebook 28

The two pointers technique is the optimal approach. Use a fast pointer that moves n+1 steps ahead, then move both pointers until fast reaches the end. When fast is null, slow will be positioned right before the target node. Time: O(n), Space: O(1)

Common Approaches

✓ One Pass - Two Pointers

⏱️ Time: O(n) Space: O(1)

Maintain two pointers separated by n nodes. When the fast pointer reaches the end, the slow pointer will be at the node before the target node. This eliminates the need to count total nodes.

Two Pass - Count Then Remove

⏱️ Time: O(n) Space: O(1)

Make two passes through the list. First pass counts total nodes to convert 'nth from end' to 'kth from start'. Second pass traverses to position k-1 and removes the next node.

One Pass - Two Pointers — Algorithm Steps

Step 1: Place fast pointer n steps ahead of slow pointer
Step 2: Move both pointers until fast reaches end
Step 3: Remove the node after slow pointer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set fast pointer n+1 steps ahead of slow

Move Together

Move both pointers until fast reaches end

Remove

Slow is now before target, remove next node

Code -

solution.c — C

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

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

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = createNode(arr[0]);
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = createNode(arr[i]);
        current = current->next;
    }
    return head;
}

void printList(struct ListNode* head) {
    printf("[");
    struct ListNode* current = head;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        first = 0;
        current = current->next;
    }
    printf("]\n");
}

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int n;
    scanf("%d", &n);
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* resultHead = solution(head, n);
    printList(resultHead);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using pointer variables, no extra data structures

✓ Linear Space

280.5K Views

High Frequency

~15 min Avg. Time

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

One Pass - Two Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler