Remove Nth Node from End — NullPointer on Head Removal

Removing the nth node from the end of a linked list is a positional deletion problem — you need to find a node by its distance from the tail without random access. The naive approach counts the length first (two passes), then walks to position L-n. The optimal approach uses a two-pointer gap in a single pass.

The critical edge case is removing the head itself (when n equals list length). Without a dummy sentinel node, this requires a separate if-branch. The dummy node makes the deletion logic uniform — slow always has a predecessor, so slow.next = slow.next.next works for every position including the head.

This pattern generalizes: any problem requiring 'find the kth element from the end' uses the same two-pointer gap technique. It is the complement of Floyd's fast/slow pattern used for cycle detection and middle-finding.

Why Removing the Nth Node from the End Is a Two-Pointer Problem

Removing the nth node from the end of a singly linked list means deleting the node that is n steps before the tail, where n is 1-indexed (n=1 removes the last node). The core mechanic uses two pointers — fast and slow — with the fast pointer advanced n steps ahead. Then both move together until fast reaches the end; slow now points to the node just before the target. This achieves the removal in one pass, O(n) time and O(1) space.

The critical property: you must handle the case where n equals the list length — that is, removing the head. In that scenario, the fast pointer becomes null after advancing n steps, and the standard loop condition fails. You detect this by checking if fast is null after the initial advance; if so, the head is the target. Without this check, you get a NullPointerException when trying to access fast.next in the loop. The two-pointer technique works because the gap between fast and slow is exactly n, so when fast lands on the last node, slow is at the node before the removal point.

Use this pattern whenever you need to find or modify a node at a known offset from the end without knowing the list length. It's common in streaming data, real-time log processing, and memory-constrained environments where you cannot buffer the entire list. The technique is also the foundation for more complex problems like rotating a list or finding the middle node — mastering it prevents off-by-one errors that crash production pipelines.

How Remove Nth Node From End Works — Step by Step

The classic approach uses two pointers separated by exactly n nodes so that when the fast pointer reaches the end, the slow pointer is at the (n+1)th node from the end — the node just before the target.

1. Create a dummy node before the head to handle edge cases like removing the head itself.
2. Set fast = dummy and slow = dummy.
3. Advance fast n+1 steps forward (n steps to create the gap, +1 so slow lands before the target).
4. Move both fast and slow one step at a time until fast reaches None.
5. Now slow.next is the node to delete. Set slow.next = slow.next.next.
6. Return dummy.next as the new head.

For list 1→2→3→4→5, remove 2nd from end (target: node 4): 1. Advance fast 3 steps: fast=node3. 2. Move together: slow=node1,fast=node4; slow=node2,fast=node5; slow=node3,fast=None. 3. Delete: node3.next = node3.next.next = node5. List: 1→2→3→5.

Worked Example — Tracing the Two-Pointer Approach

List: 1→2→3→4→5 (length 5). Remove n=2 (2nd from end = node with value 4).

Initial state: dummy→1→2→3→4→5→None. fast=slow=dummy.

slow is at node 3. slow.next is node 4 (the target). Delete: slow.next = slow.next.next (node 5).

Result: dummy→1→2→3→5→None. Return dummy.next → 1→2→3→5.

package io.thecodeforge.list;

/**
 * One-pass remove-nth-from-end with trace output for learning and debugging.
 */
public class RemoveNthFromEndDemo {

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int val) { this.val = val; }
    }

    static ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy;
        ListNode fast = dummy;

        // Advance fast n+1 steps to create the gap
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }

        // Move both until fast reaches the end
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }

        // Delete: skip the target node
        slow.next = slow.next.next;

        return dummy.next;
    }

    static String listToString(ListNode head) {
        StringBuilder sb = new StringBuilder();
        ListNode current = head;
        while (current != null) {
            sb.append(current.val);
            if (current.next != null) sb.append(" -> ");
            current = current.next;
        }
        return sb.toString();
    }

    static ListNode buildList(int[] values) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        for (int val : values) {
            tail.next = new ListNode(val);
            tail = tail.next;
        }
        return dummy.next;
    }

    public static void main(String[] args) {
        // Test 1: Remove middle node
        ListNode list1 = buildList(new int[]{1, 2, 3, 4, 5});
        System.out.println("Before: " + listToString(list1));
        ListNode result1 = removeNthFromEnd(list1, 2);
        System.out.println("After (remove 2nd from end): " + listToString(result1));

        // Test 2: Remove head (n == listLength)
        ListNode list2 = buildList(new int[]{1, 2, 3});
        ListNode result2 = removeNthFromEnd(list2, 3);
        System.out.println("Remove head (3rd from 3): " + listToString(result2));

        // Test 3: Remove tail (n == 1)
        ListNode list3 = buildList(new int[]{1, 2, 3});
        ListNode result3 = removeNthFromEnd(list3, 1);
        System.out.println("Remove tail (1st from end): " 4: Single node list
        ListNode list4 = buildList(new int[]{42});
        ListNode result4 = removeNthFromEnd(list4, 1);
        System.out.println("Single node removed: " + (result4 == null ? "(empty)" : listToString(result4)));

        // Test 5: Two node list, remove first
        ListNode list5 = buildList(new int[]{10, 20});
        ListNode result5 = removeNthFromEnd(list5, 2);
        System.out.println("Two nodes, remove head: " + listToString(result5));
    }
}

The Two-Pass Kill: Why You Don't Always Need Two Pointers

Most devs reach for the fast-slow pointer trick the second they hear 'remove nth from end.' It's elegant, it's flashy, and it's what every blog shoves down your throat. But sometimes you just want the brute-force pass that works without edge-case gymnastics.

Here's the ugly truth: a two-pointer solution needs you to manage a dummy node, offset the fast pointer by exactly N, then step both until fast hits null. Miss the offset by one? You've deleted the wrong node or blown a null pointer. Not great when you're debugging at 2 AM.

The alternative is dead simple: traverse once to get the list length, compute the target index from the front, then traverse again to that node's predecessor and cut. O(n) time, O(1) space, zero pointer wizardry. The WHY is obvious: linked lists give you O(n) random access anyway, so two traversals cost the same as one traversal with offset logic. You just trade a bit of clarity for the same big-O.

When would I use this? Production code that needs to be audited by junior devs, or when N is dynamic and the two-pointer offset logic turns into a tangled mess. Don't let the cool-factor of two pointers dictate your implementation.

// io.thecodeforge — dsa tutorial

public class RemoveNthFromEndTwoPass {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // First pass: count nodes
        int length = 0;
        ListNode current = head;
        while (current != null) {
            length++;
            current = current.next;
        }

        // Target index from front (1-based)
        int targetIndex = length - n + 1;

        // Edge case: removing head
        if (targetIndex == 1) {
            return head.next;
        }

        // Second pass: find predecessor of target
        current = head;
        for (int i = 1; i < targetIndex - 1; i++) {
            current = current.next;
        }
        // Cut the target node
        current.next = current.next.next;

        return head;
    }
}

The Dummy Node: Your Shield Against Null-Pointer Hell

Here's a pattern that separates devs who've burned their fingers from those who haven't: the dummy node. When you remove the Nth node from the end, you might need to delete the head. Without a dummy, that's a special case branch. With one, it's just another node.

Think about it: your two-pointer setup needs a 'slow' pointer that trails N steps behind 'fast.' When 'fast' hits null, 'slow' is pointing at the node just before the one you want to delete. But what if N equals the list length? Then you're deleting the head, and 'slow' never moved. Without a dummy, you either add an if-check or crash.

The dummy node fixes this: create a node that points to head, then start both pointers from the dummy. Now 'slow' always has a predecessor, even when deleting the first real node. Your code becomes uniform—no special cases, no null checks, just clean pointer surgery.

Why does this matter in production? Because linked list operations in legacy codebases are full of 'if (prev == null)' hacks that accumulate tech debt. The dummy node pattern eliminates that entire class of bugs. Use it, and your code reviewers will stop side-eyeing you.

// io.thecodeforge — dsa tutorial

public class RemoveNthFromEndDummy {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        ListNode fast = dummy;
        ListNode slow = dummy;
        
        // Advance fast by n+1 steps (due to dummy)
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }
        
        // Move both until fast hits end
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        
        // slow is now at predecessor of target
        slow.next = slow.next.next;
        
        return dummy.next;
    }
}

Statement

Given the head of a singly linked list, remove the Nth node from the end of the list and return its head. The list has at least one node, and N is guaranteed to be a valid index (1 ≤ N ≤ list length). This problem appears in coding interviews to test your ability to traverse and modify linked lists without extra space. The naive approach involves two passes: first get the total length, then locate the node before the target. But a single-pass two-pointer technique eliminates the need to know the full length upfront. Understanding this problem solidifies your grasp of pointer manipulation, edge cases like removing the head or tail, and efficient memory use. The signature in Java is: public ListNode removeNthFromEnd(ListNode head, int n).

// io.thecodeforge — dsa tutorial
public class RemoveNthNodeEnd {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy, fast = dummy;
        for (int i = 0; i < n; i++) fast = fast.next;
        while (fast.next != null) {
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

Why Linked List Removal Differs from Array Removal

Removing an element from an array is trivial: shift all later elements left. But linked lists have no random access or contiguous memory. To delete a node, you must update the previous node's 'next' pointer to skip the target. This means you need a reference to the node before the target. If the target is the head, there is no previous node—so a dummy node becomes essential to unify edge cases. Another difference: arrays require knowing the exact index, but linked lists only provide traversal from head. The 'Nth from end' twist adds complexity because you don't know the tail position without a full scan. Two pointers solve this elegantly by creating an offset from the start, simulating a 'lookahead' to locate the endpoint. This problem teaches you to think about pointer references, null propagation, and linear-time operations without extra memory.

// io.thecodeforge — dsa tutorial
public class ListVsArrayRemoval {
    // Array removal: O(n) shift
    public int[] removeFromArray(int[] arr, int idx) {
        int[] res = new int[arr.length - 1];
        System.arraycopy(arr, 0, res, 0, idx);
        System.arraycopy(arr, idx + 1, res, idx, arr.length - idx - 1);
        return res;
    }
}