Remove Nth Node from End Explained: Deleting 4 & Head from 1-5

Imagine you are given the linked list Given: 1 -> 2 -> 3 -> 4 -> 5 and asked to Remove n=2 from end, which means deleting node 4 to leave 1 -> 2 -> 3 -> 5. Your first instinct might be straightforward: walk through the entire list once to count its total nodes, subtract $n$ from that total length to find the target's forward index, and then walk through the list a second time to perform the splice. But what happens if the requirements demand a single pass?

In data stream or strict performance contexts, iterating twice is inefficient or impossible. Yet, if you only move forward pointer-by-pointer, you do not know when you are $n$ nodes away from the end because you cannot see the future. If you start deleting blindly, you might overshoot or undershoot the target node entirely. The core challenge of Remove Nth node from end of list explained is figuring out how to measure distance from a finish line that you haven't reached yet.

To make matters worse, consider the second part of our challenge: then n=5 (the head). Here, $n$ equals the exact length of the list, meaning you must delete the very first node (1), resulting in 2 -> 3 -> 4 -> 5. Without a strategy to handle the structural edge case where the head itself gets chopped, a naive single-pass loop will crash or corrupt pointer references. We need a way to orchestrate pointers so they naturally land right before our target without ever counting nodes.

For our locked example where the list is $1\to 2\to 3\to 4\to 5$ and we want to remove $n=2$, the gap between our pointers must be $2+1=3$ steps. If we introduce a dummy node at the start—making our chain $\text{dummy}\to 1\to 2\to 3\to 4\to 5$—both runners begin safely behind the real head. The fast pointer sprints ahead by 3 nodes before anyone else moves. Then, both fast and slow pointers advance together one step at a time until the fast pointer reaches the end of the list. At that exact moment, the slow pointer rests precisely on the node preceding our target 4, ready to execute a pointer bypass.

To see the gap model in action, let us trace our locked example: $head=1\to 2\to 3\to 4\to 5$ with $n=2$. We want to delete the node with value 4, which is the second node from the end.

Given:
- head: $1\to 2\to 3\to 4\to 5$
- $n=2$
- dummy: $0\to 1\to 2\to 3\to 4\to 5$

Steps:
1. Initialize pointers at dummy: Both fast and slow point to the dummy node ($val=0$).
2. Advance fast by $n+1=3$ steps:
- Step 1: fast moves to node 1
- Step 2: fast moves to node 2
- Step 3: fast moves to node 3
- Current state: slow is at dummy (0), fast is at node 3. The gap between them is exactly 3 nodes ($n+1$).
3. Advance both fast and slow in lockstep until fast reaches null:
- Iteration 1: fast moves to node 4, slow moves to node 1.
- Iteration 2: fast moves to node 5, slow moves to node 2.
- Iteration 3: fast moves to null, slow moves to node 3.
4. Perform deletion: slow.next currently points to node 4. We update slow.next = slow.next.next, which links node 3 directly to node 5.

Result:
The modified list is $1\to 2\to 3\to 5$, successfully omitting node 4.

Try this: dummy = Node(0, head)
slow = fast = dummy
for _ in range(n + 1):
fast = fast.next
while fast:
slow = slow.next
fast = fast.next
slow.next = slow.next.next

Now that you have seen how the gap handles standard nodes like $n=2$ in $1\to 2\to 3\to 4\to 5$, it is time to test your mental model on the second part of our locked example: removing $n=5$ (the entire length of the list, which means deleting the head node 1).

Before jumping to the full solution, trace through what happens when the fast pointer advances $n+1$ steps (which is $5+1=6$ steps) from the dummy node:

1. Start with dummy $\to 1\to 2\to 3\to 4\to 5$.
2. Advance fast pointer 6 total steps forward.
3. Keep slow stationary at dummy during this initial advance phase.

Answer the following question about pointer positions and node mutations for this $n=5$ head deletion task.

Now that you have mastered the dual-pointer gap mechanics for our working example of $1\to 2\to 3\to 4\to 5$ (removing $n=2$ and the head $n=5$), let us apply this exact structural pattern to a new scenario. Suppose you are given a singly linked list that you suspect might contain a cycle, but your primary constraint is that you must find the start of the cycle in $O(1)$ extra space and without computing the length beforehand.

Just as the $n+1$ gap in our base problem let us locate the target node without counting the total nodes, Floyd's Cycle-Finding Algorithm uses two pointers moving at different speeds to discover a cycle invariant. The underlying mental model remains identical: create a deterministic spatial offset between two traversal tokens so that their intersection point reveals topological metadata (the end-of-list boundary in our list removal, versus the cycle entry node in the loop detection).

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def detectCycleStart(head: ListNode) -> ListNode:
    # Apply the pointer-offset mental model here:
    # 1. Detect if a cycle exists using fast/slow pointers
    # 2. Reset one pointer to head and find the entry node
    pass