Linked List Group Reverser - Problem

Given the head of a singly linked list and an integer k, reverse every group of k consecutive nodes in the linked list.

If the number of remaining nodes is less than k, leave them in their original order.

Example:

Input: head = [1,2,3,4,5,6,7,8], k = 3
Output: [3,2,1,6,5,4,7,8]

The first group [1,2,3] becomes [3,2,1], the second group [4,5,6] becomes [6,5,4], and the remaining nodes [7,8] stay as-is since there are fewer than 3 nodes.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: First group [1,2,3] becomes [3,2,1], second group [4,5,6] becomes [6,5,4]. The remaining nodes [7,8] have fewer than k=3 nodes so they stay unchanged.

Example 2 — Perfect Groups

$ Input: head = [1,2,3,4,5,6], k = 2

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

💡 Note: All nodes form complete groups of k=2: [1,2] becomes [2,1], [3,4] becomes [4,3], [5,6] becomes [6,5].

Example 3 — No Complete Groups

$ Input: head = [1,2,3], k = 4

› Output: [1,2,3]

💡 Note: Since there are only 3 nodes but k=4, no complete group exists. The list remains unchanged.

Constraints

1 ≤ number of nodes ≤ 5000
0 ≤ Node.val ≤ 1000
1 ≤ k ≤ number of nodes

Visualization

Tap to expand

Asked in

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

The key insight is to reverse each complete group of k nodes in-place using pointer manipulation. The optimal approach uses recursion to handle groups systematically: count k nodes, reverse if complete group exists, then recursively process the rest. Time: O(n), Space: O(1).

Common Approaches

✓ Convert to Array and Back

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

First traverse the linked list to convert all values to an array. Then reverse every group of k elements in the array. Finally, create a new linked list from the modified array.

In-Place Group Reversal

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

Traverse the linked list and for each complete group of k nodes, reverse the links between them in-place. Use three pointers to track previous, current, and next nodes during reversal.

Convert to Array and Back — Algorithm Steps

Convert linked list to array by traversing all nodes
Reverse every complete group of k elements in the array
Build new linked list from the modified array

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Extract all values from linked list into array

Reverse Groups

Reverse every complete group of k elements

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 k) {
    if (!head || k == 1) return head;
    
    // Count nodes and convert to array
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        count++;
        curr = curr->next;
    }
    
    int* arr = (int*)malloc(count * sizeof(int));
    curr = head;
    for (int i = 0; i < count; i++) {
        arr[i] = curr->val;
        curr = curr->next;
    }
    
    // Reverse every group of k
    for (int i = 0; i <= count - k; i += k) {
        int left = i, right = i + k - 1;
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    
    // Build new linked list
    if (count == 0) {
        free(arr);
        return NULL;
    }
    
    struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    newHead->val = arr[0];
    newHead->next = NULL;
    
    curr = newHead;
    for (int i = 1; i < count; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = arr[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    
    free(arr);
    return newHead;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int k;
    scanf("%d", &k);
    
    // Parse array
    int arr[1000];
    int size = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            arr[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* resultHead = solution(head, k);
    
    // Print result
    printf("[");
    struct ListNode* curr = resultHead;
    int first = 1;
    while (curr) {
        if (!first) printf(",");
        printf("%d", curr->val);
        first = 0;
        curr = curr->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate O(n) passes: convert to array, reverse groups, rebuild list

✓ Linear Growth

Space Complexity

O(n)

Extra array stores all n node values

⚡ Linearithmic Space

68.0K Views

High Frequency

~25 min Avg. Time

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

Linked List Group Reverser - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Convert to Array and Back — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler