Reverse Linked List

Reverse Linked List - Problem

Given the head of a singly linked list, reverse the list, and return the reversed list.

A singly linked list is a data structure where each node contains a value and a reference to the next node in the sequence. Reversing the list means changing the direction of all pointers so that the last node becomes the first, and the first node becomes the last.

Input & Output

Example 1 — Basic List

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

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

💡 Note: The linked list 1→2→3→4→5 becomes 5→4→3→2→1 after reversing all the pointer directions.

Example 2 — Two Nodes

$ Input: head = [1,2]

› Output: [2,1]

💡 Note: Simple case with two nodes: 1→2 becomes 2→1.

Example 3 — Empty List

$ Input: head = []

› Output: []

💡 Note: An empty list remains empty after reversal.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 85 M Microsoft 72 G Google 68 🍎 Apple 45 f Facebook 42

The key insight is to use three pointers (prev, current, next) to safely reverse each link without losing track of the remaining list. The optimal iterative approach achieves O(n) time and O(1) space by reversing pointers in place during a single traversal.

Common Approaches

✓ Array Collection Approach

⏱️ Time: O(n) Space: O(n)

Traverse the linked list to collect all node values into an array. Then create a new linked list by iterating through the array in reverse order.

Iterative Pointer Reversal

⏱️ Time: O(n) Space: O(1)

Maintain three pointers (previous, current, next) and iterate through the list once, reversing each link by updating the next pointer of the current node to point to the previous node.

Recursive Approach

⏱️ Time: O(n) Space: O(n)

Recursively traverse to the end of the list, then reverse the pointers on the way back up the call stack. The base case returns the last node as the new head.

Array Collection Approach — Algorithm Steps

Traverse the linked list and store all values in an array
Create new nodes using values from the array in reverse order
Connect the new nodes to form the reversed linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse Original

Walk through list collecting values [1,2,3,4,5]

Reverse Array

Process array from end to start

Build New List

Create new nodes in reverse order

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* solution(struct ListNode* head) {
    if (!head) return NULL;
    
    // Collect all values
    int values[5000];
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        values[count++] = current->val;
        current = current->next;
    }
    
    // Create new reversed list
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    current = dummy;
    for (int i = count - 1; i >= 0; i--) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = values[i];
        current->next->next = NULL;
        current = current->next;
    }
    
    return dummy->next;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = arr[i];
        current->next->next = NULL;
        current = current->next;
    }
    return head;
}

void listToArray(struct ListNode* head, int* arr, int* size) {
    *size = 0;
    struct ListNode* current = head;
    while (current) {
        arr[(*size)++] = current->val;
        current = current->next;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[5000];
    int size = 0;
    
    if (strncmp(line, "[]", 2) != 0) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            arr[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    int output[5000];
    int outputSize;
    listToArray(result, output, &outputSize);
    
    printf("[");
    for (int i = 0; i < outputSize; i++) {
        if (i > 0) printf(",");
        printf("%d", output[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the list: once to collect values, once to create new nodes

✓ Linear Growth

Space Complexity

O(n)

Array stores all n node values plus space for new nodes

⚡ Linearithmic Space

1.3M Views

Very High Frequency

~15 min Avg. Time

15.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array Collection Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler