How do you approach Reverse Linked List?

Think about how you would reverse an array in place.

What is the time complexity of Reverse Linked List?

Time complexity: O(n) - single pass through the array. Space complexity: O(1) if reversing in place, O(n) if creating a new array.

What are common mistakes on Reverse Linked 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

Reverse Linked List

EasyData Structures

Description

Given the head of a singly linked list (represented as an array), reverse the list and return the reversed list as an array. For example, the linked list `1 -> 2 -> 3 -> 4 -> 5` is represented as the array `[1, 2, 3, 4, 5]`. After reversing, return `[5, 4, 3, 2, 1]`.

Example 1

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

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

Example 2

Input: head = [1, 2]

Output: [2, 1]

Example 3

Input: head = []

Output: []

Constraints

- The number of nodes in the list is in the range [0, 5000]. - -5000 <= Node.val <= 5000

Reverse Linked List: approach, complexity and pitfalls

An easy 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

Think about how you would reverse an array in place.
You can build the reversed list by iterating through the original and building a new result.
Alternatively, use the array reverse method or two-pointer approach.

The optimal approach

Show the approach: Iterative Reversal

Since the linked list is represented as an array, we can reverse it in place using two pointers or simply use the built-in reverse method.

To simulate actual linked list reversal logic: iterate through the array and build a new reversed array by prepending each element.

Time: O(n) - single pass through the array
Space: O(1) if reversing in place, O(n) if creating a new array

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.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
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.