Reverse Linked List II

Reverse Linked List II - Problem

Linked List Medium

Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list.

The positions are 1-indexed.

Input & Output

Example 1 — Basic Reversal

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

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

💡 Note: Reverse nodes from position 2 to 4: 2→3→4 becomes 4→3→2, while nodes 1 and 5 remain in place

Example 2 — Single Node

$ Input: head = [5], left = 1, right = 1

› Output: [5]

💡 Note: Only one node and reversing position 1 to 1 means no change needed

Example 3 — Full List Reversal

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

› Output: [5,3]

💡 Note: Reverse the entire list from position 1 to 2: 3→5 becomes 5→3

Constraints

The number of nodes in the list is n
1 ≤ n ≤ 500
-500 ≤ Node.val ≤ 500
1 ≤ left ≤ right ≤ n

Visualization

Tap to expand

Asked in

f Facebook 45 a Amazon 38 M Microsoft 32 G Google 28

The optimal approach uses three-pointer technique to reverse the sublist in-place. Key insight: maintain connections to unreversed parts while reversing links one by one. Best approach is one-pass pointer reversal with Time: O(n), Space: O(1).

Common Approaches

✓ Convert to Array and Back

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

First traverse the entire list to store values in an array. Reverse the specified portion of the array, then create a new linked list from the modified array values.

One-Pass Pointer Reversal

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

Find the start of the reversal section, then use three pointers (prev, curr, next) to reverse links one by one. Maintain connections to the parts before and after the reversed section.

Convert to Array and Back — Algorithm Steps

Step 1: Traverse list and store all values in array
Step 2: Reverse subarray from index left-1 to right-1
Step 3: Create new linked list from modified array

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Extract all values from linked list into array

Reverse Subarray

Reverse elements from index left-1 to right-1

Rebuild List

Create new linked list from modified array

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, int left, int right) {
    if (!head || left == right) return head;
    
    int values[5000];
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        values[count++] = curr->val;
        curr = curr->next;
    }
    
    int leftIdx = left - 1, rightIdx = right - 1;
    while (leftIdx < rightIdx) {
        int temp = values[leftIdx];
        values[leftIdx] = values[rightIdx];
        values[rightIdx] = temp;
        leftIdx++;
        rightIdx--;
    }
    
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    curr = dummy;
    
    for (int i = 0; i < count; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = values[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    
    return dummy->next;
}

int* listToArray(struct ListNode* head, int* returnSize) {
    int* result = (int*)malloc(5000 * sizeof(int));
    *returnSize = 0;
    struct ListNode* curr = head;
    while (curr) {
        result[(*returnSize)++] = curr->val;
        curr = curr->next;
    }
    return result;
}

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* curr = head;
    for (int i = 1; i < size; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = arr[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    return head;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int headArr[500];
    int headSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        headArr[headSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int left, right;
    scanf("%d", &left);
    scanf("%d", &right);
    
    struct ListNode* head = arrayToList(headArr, headSize);
    struct ListNode* resultHead = solution(head, left, right);
    int resultSize;
    int* result = listToArray(resultHead, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three passes: one to read list into array, one to reverse subarray, one to build new list

✓ Linear Growth

Space Complexity

O(n)

Array stores all n node values plus new list nodes

⚡ Linearithmic Space

587.0K Views

High Frequency

~15 min Avg. Time

8.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

Convert to Array and Back — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler