Reverse Linked List - Practice Coding Problems

Reverse Linked List - Problem

Given the head of a singly linked list, your task is to reverse the entire list and return the new head of the reversed list.

Imagine you have a chain of nodes where each node points to the next one: 1 → 2 → 3 → 4 → 5 → NULL. After reversing, it should become: 5 → 4 → 3 → 2 → 1 → NULL.

What you need to do:

Take a linked list as input
Reverse the direction of all pointers
Return the new head (which was originally the tail)
Handle edge cases like empty lists or single nodes

This is a fundamental problem that tests your understanding of pointer manipulation and is frequently asked in technical interviews!

Input & Output

example_1.py — Basic Reversal

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

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

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

example_2.py — Two Node List

$ Input: [1,2]

› Output: [2,1]

💡 Note: A simple two-node list 1→2→NULL becomes 2→1→NULL. The first node now points to NULL and second points to first.

example_3.py — Single Node

$ Input: [1]

› Output: [1]

💡 Note: A single node list remains unchanged since there are no pointers to reverse. The node still points to NULL.

Visualization

Tap to expand

Understanding the Visualization

Setup the Formation

Position three key people: Previous (start), Current (first person), and Next (second person)

Save the Chain

Next person remembers who comes after them before the current person turns around

Turn Around

Current person turns to face and hold hands with the Previous person

Move Forward

Everyone shifts positions: Previous becomes Current, Current becomes Previous, Next becomes Current

Repeat the Dance

Continue this pattern until everyone has turned around - the last person is now the leader!

Key Takeaway

🎯 Key Insight: We only need to track three consecutive nodes at any time. By carefully managing these three pointers (prev, curr, next), we can reverse all links in a single pass without using extra space for data storage.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the list once to build array O(n), reverse array O(n), then build new list O(n), giving us O(3n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

We need extra space for the array to store all node values, plus space for the new linked list nodes

⚡ Linearithmic Space

Constraints

The number of nodes in the list is the range [0, 5000]
-5000 ≤ Node.val ≤ 5000
The linked list is guaranteed to be valid

Asked in

G Google 45 a Amazon 52 f Meta 38 ⊞ Microsoft 41 Apple 29

The optimal solution uses an iterative three-pointer technique with O(1) space complexity. We maintain prev, current, and next pointers to reverse each link in a single pass through the list. This approach is preferred over recursive solutions as it avoids stack overflow for large lists and uses constant extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Array Conversion)	O(n)	O(n)	Convert to array, reverse array, rebuild linked list
Iterative Two Pointers (Optimal)	O(n)	O(1)	Use previous, current, and next pointers to reverse links in one pass

Brute Force (Array Conversion) — Algorithm Steps

Traverse the linked list and store all node values in an array
Reverse the array using built-in reverse function
Create new nodes and build a new linked list from reversed array
Return the head of the new reversed linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Traverse linked list and store values in array: [1,2,3,4,5]

Reverse Array

Use built-in reverse to get: [5,4,3,2,1]

Rebuild List

Create new linked list from reversed array: 5→4→3→2→1→NULL

Code -

solution.c — C

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

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

struct ListNode* reverseList(struct ListNode* head) {
    if (!head) return NULL;
    
    // Step 1: Count nodes and store values
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    int* values = (int*)malloc(count * sizeof(int));
    current = head;
    for (int i = 0; i < count; i++) {
        values[i] = current->val;
        current = current->next;
    }
    
    // Step 2: Reverse array
    for (int i = 0; i < count / 2; i++) {
        int temp = values[i];
        values[i] = values[count - 1 - i];
        values[count - 1 - i] = temp;
    }
    
    // Step 3: Build new list
    struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    newHead->val = values[0];
    newHead->next = NULL;
    current = newHead;
    
    for (int i = 1; i < count; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = values[i];
        current->next->next = NULL;
        current = current->next;
    }
    
    free(values);
    return newHead;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    if (strstr(input, "[]")) {
        printf("null\n");
        return 0;
    }
    
    // Parse input and create linked list
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    sscanf(input, "[%d", &head->val);
    head->next = NULL;
    
    struct ListNode* current = head;
    char* ptr = strchr(input, ',');
    
    while (ptr) {
        int val;
        sscanf(ptr + 1, "%d", &val);
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = val;
        current->next->next = NULL;
        current = current->next;
        ptr = strchr(ptr + 1, ',');
    }
    
    struct ListNode* result = reverseList(head);
    printf("[");
    int first = 1;
    while (result) {
        if (!first) printf(",");
        printf("%d", result->val);
        result = result->next;
        first = 0;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the list once to build array O(n), reverse array O(n), then build new list O(n), giving us O(3n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

We need extra space for the array to store all node values, plus space for the new linked list nodes

⚡ Linearithmic Space

Constraints

The number of nodes in the list is the range [0, 5000]
-5000 ≤ Node.val ≤ 5000
The linked list is guaranteed to be valid

95.4K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Array Conversion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler