Reverse Linked List - Practice Coding Problems

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

Understanding the Visualization

Input

Original linked list: 1→2→3→4→5

Process

Reverse all pointer directions

Output

Reversed linked list: 5→4→3→2→1

Key Takeaway

🎯 Key Insight: Use three pointers to safely reverse each link without losing the rest of the list

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

Approach	Time	Space	Notes
✓ Iterative Pointer Reversal	O(n)	O(1)	Use three pointers to reverse the direction of each link in a single pass
Recursive Approach	O(n)	O(n)	Use recursion to reverse the list by processing from the end back to the beginning
Array Collection Approach	O(n)	O(n)	Collect all values in an array, then rebuild the linked list in reverse order

Iterative Pointer Reversal — Algorithm Steps

Initialize prev=null, current=head
For each node, save next pointer, reverse current.next to prev
Move all three pointers forward and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set prev=null, current=head

Reverse Link

Point current.next to prev

Move Forward

Advance all pointers and repeat

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) {
    struct ListNode* prev = NULL;
    struct ListNode* current = head;
    
    while (current) {
        struct ListNode* nextNode = current->next;  // Save next
        current->next = prev;                      // Reverse link
        prev = current;                           // Move prev forward
        current = nextNode;                       // Move current forward
    }
    
    return prev;
}

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;
    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)

Single pass through all n nodes in the linked list

✓ Linear Growth

Space Complexity

O(1)

Only uses three pointer variables regardless of list size

✓ Linear 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

Iterative Pointer Reversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler