Reverse Nodes in k-Group

Reverse Nodes in k-Group - Problem

Given the head of a linked list, reverse the nodes of the list k at a time, and return the modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should remain as it is.

You may not alter the values in the list's nodes, only nodes themselves may be changed.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Reverse first 2 nodes: [1,2] becomes [2,1]. Reverse next 2 nodes: [3,4] becomes [4,3]. Node 5 remains as is since it's incomplete group.

Example 2 — Perfect Groups

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

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

💡 Note: Reverse first 3 nodes: [1,2,3] becomes [3,2,1]. Reverse next 3 nodes: [4,5,6] becomes [6,5,4]. All nodes form complete groups.

Example 3 — Single Node

$ Input: head = [1], k = 1

› Output: [1]

💡 Note: When k=1, no reversal needed. Return original list unchanged.

Constraints

The number of nodes in the list is n.
1 ≤ k ≤ n ≤ 5000
0 ≤ Node.val ≤ 1000

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 three pointers, leaving incomplete groups unchanged. The optimal approach uses recursion with O(1) extra space and O(n) time complexity.

Common Approaches

✓ Array Conversion Approach

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

Convert the entire linked list to an array, reverse every complete group of k elements in the array, then rebuild the linked list from the modified array.

In-Place Reversal

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

Traverse the linked list and for each complete group of k nodes, reverse the links in-place using three pointers (previous, current, next). Skip incomplete groups at the end.

Array Conversion Approach — Algorithm Steps

Step 1: Convert linked list to array
Step 2: Reverse every k elements in array
Step 3: Rebuild linked list from array

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Transform linked list to array

Reverse Groups

Reverse every k elements

Rebuild List

Convert array back to linked list

Code -

solution.c — C

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

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

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = arr[i];
        current->next = NULL;
    }
    return head;
}

int listToArray(struct ListNode* head, int* arr) {
    int size = 0;
    struct ListNode* current = head;
    while (current) {
        arr[size++] = current->val;
        current = current->next;
    }
    return size;
}

struct ListNode* solution(struct ListNode* head, int k) {
    if (!head || k == 1) return head;
    
    // Convert to array
    int arr[1000];
    int n = listToArray(head, arr);
    
    // Reverse every k elements
    for (int i = 0; i <= n - k; i += k) {
        for (int j = i, l = i + k - 1; j < l; j++, l--) {
            int temp = arr[j];
            arr[j] = arr[l];
            arr[l] = temp;
        }
    }
    
    // Convert back to linked list
    return arrayToList(arr, n);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int headArr[1000];
    int size = 0;
    
    // Find start of array
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        char* endptr;
        headArr[size++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
    
    int k;
    scanf("%d", &k);
    
    struct ListNode* head = arrayToList(headArr, size);
    struct ListNode* result = solution(head, k);
    
    int resultArr[1000];
    int resultSize = listToArray(result, resultArr);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", resultArr[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to convert to array + single pass to reverse groups + single pass to rebuild

✓ Linear Growth

Space Complexity

O(n)

Array stores all n node values

⚡ Linearithmic Space

78.0K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Array Conversion Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler