How do you approach Remove Nth Node From End of List?

The n-th node from the end is the (length - n)-th node from the front.

What is the time complexity of Remove Nth Node From End of List?

Time complexity: O(n) - single pass. Space complexity: O(1) extra.

What are common mistakes on Remove Nth Node From End of List?

Reassigning next before saving it, which loses the rest of the list. Skipping the dummy head, which forces a special case every time the real head changes. Advancing the fast pointer without checking both fast and fast.next - the null dereference only shows up on even-length lists.

gitGood.dev

← Back to problems

Remove Nth Node From End of List

MediumData Structures

Description

Given the head of a linked list, remove the n-th node **from the end** of the list and return its head. **Note:** For this problem, linked lists are represented as arrays for simplicity. The function takes the list as an array and should return the resulting list as an array. **Follow-up:** on a real singly linked list, could you do this in one pass without knowing the length in advance?

Example 1

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

Output: [1,2,3,5]

Explanation: The 2nd node from the end is 4.

Example 2

Input: head = [1], n = 1

Output: []

Example 3

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

Output: [1]

Constraints

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

Remove Nth Node From End of List: approach, complexity and pitfalls

A medium linked list problem, graded against 6 test cases (3 of them hidden).

The pattern: Linked List

Pointer manipulation - reversal, cycle detection, and merging without extra space.

Reach for it when you see: Any problem handing you a list head, especially with an O(1) space constraint.

If you are stuck

Show the 3-step hint ladder

The n-th node from the end is the (length - n)-th node from the front.
For a single pass: advance a lead pointer n steps first, then move lead and trail together until lead falls off the end.
Removing the head itself (n == length) is the classic edge case - a dummy node in front of the head makes it uniform.

The optimal approach

Show the approach: Two Pointers with a Gap

Advance a `lead` pointer n steps ahead, then move `lead` and `trail` together. When `lead` walks off the end, `trail` is exactly on the node to delete - one pass, no length precomputation. On a real list you'd start both pointers at a dummy node before the head so that deleting the first node needs no special case.

Time: O(n) - single pass
Space: O(1) extra

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.

Common Linked List mistakes

These apply to the pattern as a whole, not just this problem.

Reassigning `next` before saving it, which loses the rest of the list.
Skipping the dummy head, which forces a special case every time the real head changes.
Advancing the fast pointer without checking both `fast` and `fast.next` - the null dereference only shows up on even-length lists.