Reverse Linked List II - Practice Coding Problems

Reverse Linked List II - Problem

Linked List Medium

Reverse Linked List II is a classic linked list manipulation problem that tests your ability to work with pointers and maintain proper connections.

You're given the head of a singly linked list and two integers left and right where left ≤ right. Your task is to reverse only the nodes from position left to position right (1-indexed), while keeping the rest of the list intact.

For example, if you have the list 1→2→3→4→5 and need to reverse from position 2 to 4, the result should be 1→4→3→2→5. Notice how only the middle section gets reversed while the surrounding nodes remain in their original positions.

This problem requires careful pointer manipulation to avoid breaking the list connections during the reversal process.

Input & Output

example_1.py — Basic Reversal

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

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

💡 Note: We reverse the sublist from position 2 to 4. The nodes 2→3→4 become 4→3→2, while positions 1 and 5 remain unchanged.

example_2.py — Single Node Reversal

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

› Output: [5]

💡 Note: When left equals right, we're reversing a single node, so the list remains unchanged.

example_3.py — Reverse Entire List

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

› Output: [5,3]

💡 Note: When we reverse from position 1 to the last position, we effectively reverse the entire linked list.

Constraints

The number of nodes in the list is n
1 ≤ n ≤ 500
-500 ≤ Node.val ≤ 500
1 ≤ left ≤ right ≤ n
Follow up: Could you do it in one pass?

Visualization

Tap to expand

Understanding the Visualization

Position the Conductor

Find the car just before the section to reverse (like finding prevLeft node)

Disconnect and Reverse

Carefully disconnect cars in the target section and reverse their order using coupling manipulation

Reconnect the Train

Attach the reversed section back to both ends of the original train to complete the operation

Key Takeaway

🎯 Key Insight: The optimal approach treats the problem like a train conductor carefully rearranging cars - find the right position, reverse the middle section using pointer manipulation, then reconnect everything without losing any connections!

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 f Meta 28 Apple 22

The optimal solution uses in-place pointer manipulation with O(1) space complexity. Key insight: maintain a reference to the node before the reversal section, reverse the middle portion using three pointers (prev, curr, next), then reconnect the reversed section to the rest of the list. This approach requires only one pass through the list and reuses existing nodes.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Reversal (Optimal)	O(n)	O(1)	Use three pointers to reverse the sublist in-place with one pass

Iterative Reversal (Optimal) — Algorithm Steps

Find the node just before the left position (prevLeft)
Use three pointers (prev, curr, next) to reverse nodes from left to right
Keep track of the first node in the reversed section to reconnect later
Reconnect the reversed section to the rest of the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Pointers

Create dummy node and find the position just before 'left'

Reverse Section

Use three pointers to reverse nodes from left to right

Reconnect

Reconnect the reversed section to the rest of the list

Code -

solution.c — C

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

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

struct ListNode* reverseBetween(struct ListNode* head, int left, int right) {
    if (!head || left == right) return head;
    
    // Create dummy node to handle edge case where left = 1
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* prevLeft = dummy;
    
    // Move to the node just before the left position
    for (int i = 0; i < left - 1; i++) {
        prevLeft = prevLeft->next;
    }
    
    // Start of the reversal section
    struct ListNode* reverseStart = prevLeft->next;
    
    // Reverse the nodes from left to right
    struct ListNode* prev = NULL;
    struct ListNode* current = reverseStart;
    
    for (int i = 0; i < right - left + 1; i++) {
        struct ListNode* nextNode = current->next;
        current->next = prev;
        prev = current;
        current = nextNode;
    }
    
    // Reconnect the reversed section
    prevLeft->next = prev;      // Connect to the new start of reversed section
    reverseStart->next = current;  // Connect to the rest of the list
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

int main() {
    // Parse input, build linked list, solve and output
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the list once to find the position and perform the reversal. In worst case, we visit each node once.

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant number of pointer variables regardless of input size

✓ Linear Space

78.5K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Iterative Reversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler