Reverse Nodes in Even Length Groups

Reverse Nodes in Even Length Groups - Problem

Linked List Medium

You're given the head of a linked list and need to perform a fascinating grouping and reversal operation!

Here's how the grouping works:

Nodes are divided into sequential groups with lengths following the natural number sequence: 1, 2, 3, 4, 5, ...
Group 1: Contains 1 node (the 1st node)
Group 2: Contains 2 nodes (the 2nd and 3rd nodes)
Group 3: Contains 3 nodes (the 4th, 5th, and 6th nodes)
And so on...

Important note: The last group might be incomplete if there aren't enough remaining nodes.

Your task: Reverse the nodes in each group that has an even length, then return the head of the modified linked list.

For example, if a group has 2 nodes (even), reverse them. If a group has 3 nodes (odd), leave them unchanged.

Input & Output

example_1.py — Basic Case

$ Input: head = [5,2,6,3,9,1,7,3,8,4]

› Output: [5,6,2,3,9,1,4,8,3,7]

💡 Note: Groups: [5], [2,6], [3,9,1], [7,3,8,4]. Group 2 (size 2) and group 4 (size 4) are even, so they get reversed: [5] → [6,2] → [3,9,1] → [4,8,3,7]

example_2.py — Small List

$ Input: head = [1,1,0,6]

› Output: [1,0,1,6]

💡 Note: Groups: [1], [1,0], [6]. Only group 2 has even length (2), so reverse it: [1] → [0,1] → [6] = [1,0,1,6]

example_3.py — Single Node

$ Input: head = [2]

› Output: [2]

💡 Note: Only one group of size 1 (odd), so no changes are made.

Constraints

The number of nodes in the list is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁶
The linked list is guaranteed to have at least one node

Visualization

Tap to expand

Asked in

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

The optimal approach uses a single pass through the linked list, processing groups incrementally. For each group of size k, we count available nodes, and if the count is even, we immediately reverse those nodes before moving to the next group. This achieves O(n) time complexity with O(1) space complexity, making it the most efficient solution.

Common Approaches

✓ Single Pass Optimal Approach

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

Traverse the linked list once, determining group boundaries on the fly. When we complete an even-length group, immediately reverse it before continuing to the next group.

Single Pass Optimal Approach — Algorithm Steps

Start with group size 1 and traverse the linked list
For each group, collect nodes up to the expected group size
If group size is even, reverse the collected nodes immediately
If group size is odd, leave nodes as-is
Move to next group with incremented group size
Handle incomplete last group appropriately

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Group 1

Group size 1 (odd) - no reversal needed

Process Group 2

Group size 2 (even) - reverse immediately

Process Group 3

Group size 3 (odd) - no reversal needed

Continue

Process remaining groups incrementally

Code -

solution.c — C

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

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

struct ListNode* reverseKNodes(struct ListNode* head, int k) {
    struct ListNode* prev = NULL;
    struct ListNode* current = head;
    
    for (int i = 0; i < k; i++) {
        if (!current) break;
        struct ListNode* nextNode = current->next;
        current->next = prev;
        prev = current;
        current = nextNode;
    }
    
    return prev;
}

struct ListNode* reverseEvenLengthGroups(struct ListNode* head) {
    if (!head) return head;
    
    struct ListNode* prevTail = NULL;
    struct ListNode* current = head;
    int groupSize = 1;
    
    while (current) {
        // Count nodes in current group
        struct ListNode* groupStart = current;
        int count = 0;
        struct ListNode* temp = current;
        
        // Count available nodes for this group
        while (temp && count < groupSize) {
            temp = temp->next;
            count++;
        }
        
        // If even number of nodes in this group, reverse them
        if (count % 2 == 0) {
            // Find the actual end of the group
            struct ListNode* groupEnd = current;
            for (int i = 0; i < count - 1; i++) {
                groupEnd = groupEnd->next;
            }
            
            struct ListNode* nextGroupStart = groupEnd->next;
            
            // Disconnect the group
            groupEnd->next = NULL;
            
            // Reverse the group
            struct ListNode* reversedHead = reverseKNodes(groupStart, count);
            
            // Connect with previous part
            if (prevTail) {
                prevTail->next = reversedHead;
            } else {
                head = reversedHead;
            }
            
            // After reversal, groupStart becomes the tail
            groupStart->next = nextGroupStart;
            prevTail = groupStart;
            current = nextGroupStart;
        } else {
            // Skip odd length group
            for (int i = 0; i < count; i++) {
                prevTail = current;
                current = current->next;
            }
        }
        
        groupSize++;
    }
    
    return head;
}

struct ListNode* parseList(char* s) {
    // Remove brackets
    char* start = strchr(s, '[');
    char* end = strchr(s, ']');
    if (!start || !end) return NULL;
    
    start++; // skip '['
    *end = '\0'; // terminate at ']'
    
    if (strlen(start) == 0) return NULL;
    
    struct ListNode* head = NULL;
    struct ListNode* current = NULL;
    
    char* token = strtok(start, ",");
    while (token) {
        int val = atoi(token);
        struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
        node->val = val;
        node->next = NULL;
        
        if (!head) {
            head = node;
            current = node;
        } else {
            current->next = node;
            current = node;
        }
        
        token = strtok(NULL, ",");
    }
    
    return head;
}

void printList(struct ListNode* head) {
    printf("[");
    struct ListNode* current = head;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        first = 0;
        current = current->next;
    }
    printf("]\n");
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin)) {
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        
        struct ListNode* head = parseList(line);
        struct ListNode* resultHead = reverseEvenLengthGroups(head);
        printList(resultHead);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes, each node is processed at most twice (once for identification, once for potential reversal)

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for pointers

✓ Linear Space

89.2K Views

Medium Frequency

~18 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

Single Pass Optimal Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler