Remove nth node from end of list

Background and context

Linked lists behave differently from arrays because each element stores a reference to the next node instead of occupying consecutive memory locations. That single design choice changes how deletion works. In an array, removing an element often means shifting values. In a linked list, the data usually stays where it is—the references simply change.

The challenge becomes more interesting when the node to delete is counted from the end rather than the beginning. Imagine a list containing:

1 → 2 → 3 → 4 → 5

If the value of n is 2, the second node from the end is 4, producing:

1 → 2 → 3 → 5

But deleting the fifth node from the end removes the head itself. That special case catches many beginners because there is no previous node before the head.

And this is why interviewers like the problem. They want to see whether candidates think beyond the obvious implementation. The best solutions handle empty lists, single-node lists, and cases where the first element disappears without adding unnecessary complexity.

The problem also introduces an idea that appears repeatedly in algorithms: using two pointers moving through the same data structure at different positions (an approach sometimes called the fast-and-slow pointer technique). Once understood, that pattern becomes useful for detecting cycles, finding middle nodes, and solving many other linked list questions.

The main substance

A beginner often solves this problem with two complete traversals. During the first traversal, the algorithm counts the total number of nodes. During the second, it calculates which node should be removed from the beginning.

For example:

Input:

1 → 2 → 3 → 4 → 5

n = 2

Step 1:
Count total nodes = 5.

Step 2:
Target position from the front:

5 - 2 = 3

Move to the third node, then adjust the next pointer so node 3 points directly to node 5.

This approach works well, but it requires traversing the linked list twice.

A more elegant solution uses two pointers.

Create a temporary dummy node before the head (this small addition dramatically simplifies deleting the first node). Place both the fast and slow pointers at the dummy node. Move the fast pointer ahead by n + 1 positions. After that, move both pointers together until the fast pointer reaches the end.

At that moment:

• The slow pointer sits immediately before the node that should be deleted.
• Updating one pointer removes the target node.
• The entire operation finishes in one traversal.

Consider this example:

Dummy → 1 → 2 → 3 → 4 → 5

For n = 2:

Move fast four steps:

Fast → 4
Slow → Dummy

Move both pointers together:

Fast → End
Slow → 3

Since slow points to node 3, changing:

3.next = 5

removes node 4.

The time complexity is O(n) because every node is visited at most once.

The space complexity remains O(1) since no extra data structure grows with the input size.

Here is a commonly accepted implementation in C++:

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;

        ListNode* fast = dummy;
        ListNode* slow = dummy;

        for(int i = 0; i <= n; i++) {
            fast = fast->next;
        }

        while(fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }

        slow->next = slow->next->next;

        return dummy->next;
    }
};

But there’s a small caveat (and experienced developers notice it quickly). If the input constraints allow invalid values of n, additional checks become necessary to avoid dereferencing a null pointer. Competitive programming platforms usually guarantee valid input, while production software often cannot make that assumption.

The truth is, interviewers generally care less about memorizing this exact code than about understanding why the two-pointer gap works.

Practical angle

Many developers dismiss linked list questions because modern software relies heavily on arrays, vectors, and dynamic collections. Realistically, that misses the broader lesson.

The underlying thinking behind this problem appears in production systems more often than the linked list itself.

Database engines use pointer-like structures internally. Operating systems manage linked data structures in memory allocation. Browser rendering engines connect objects through references. Even cache implementations frequently combine linked lists with hash tables to build efficient Least Recently Used (LRU) caches.

And once you become comfortable maintaining a fixed distance between two pointers, several well-known interview problems become much easier. These include:

• Finding the middle node without counting every element first.
• Detecting loops using Floyd’s Cycle Detection Algorithm.
• Reversing nodes in groups.
• Reordering linked lists while preserving existing connections.

For coding interviews, practice should extend beyond writing a correct answer. Spend time drawing each pointer movement on paper. Many candidates discover bugs visually long before running the code.

Or consider explaining the algorithm aloud while solving it. Interviewers often evaluate communication alongside technical accuracy, especially during live coding sessions.

One more practical habit helps: test unusual inputs.

• A single-node linked list.
• Removing the head.
• Removing the last node.
• A list with only two elements.
• The smallest valid value of n.
• The largest valid value of n.

Those cases expose mistakes that ordinary examples rarely reveal.

What to know going forward

Understanding this problem opens the door to a wider family of linked list algorithms. Instead of memorizing isolated solutions, focus on the recurring patterns behind them. The dummy node technique reduces special-case logic. Maintaining a fixed pointer gap eliminates extra traversals. Careful pointer updates prevent memory and reference errors.

So each time you practice another linked list problem, ask yourself whether counting nodes is actually necessary. Often, there is a smarter traversal waiting to be discovered.

Programming interviews also evolve. While companies may change specific questions, they continue testing reasoning, efficiency, and clean code. Mastering this challenge provides experience with all three qualities in a single exercise, making the effort worthwhile even if the exact question never appears again.

Closing

Few algorithm problems pack as many lessons into such a short piece of code as remove nth node from end of list. It teaches efficient traversal, careful pointer management, thoughtful handling of edge cases, and clean algorithm design without unnecessary memory usage. Instead of memorizing the implementation, spend time understanding why each pointer moves when it does. Your next step should be to solve the problem from scratch, then revisit it a day later without looking at any reference. If the logic still feels natural, you’ve learned far more than one interview question