Reverse Nodes in k-Group - Practice Coding Problems

Reverse Nodes in k-Group - Problem

Imagine you have a linked list that you need to reverse in groups of k nodes at a time. This is like organizing a line of people into groups and having each group face the opposite direction!

Given the head of a linked list, your task is to:

Reverse the nodes of the list k at a time
Return the modified list
Important: If the remaining nodes are fewer than k, leave them as they are
You can only rearrange the node pointers - no changing values!

Example: If you have list 1→2→3→4→5 and k=3, you get 3→2→1→4→5 (first 3 nodes reversed, last 2 unchanged)

Input & Output

example_1.py — Basic Group Reversal

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

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

💡 Note: We have two complete groups of 2 nodes each: (1,2) becomes (2,1), (3,4) becomes (4,3), and the remaining node 5 stays as is.

example_2.py — Larger Groups

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

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

💡 Note: Only one complete group of 3 nodes: (1,2,3) becomes (3,2,1). The remaining 2 nodes (4,5) are fewer than k=3, so they remain unchanged.

example_3.py — Edge Case

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

› Output: [1]

💡 Note: With k=1, each group has only 1 node, so reversing doesn't change anything. The list remains [1].

Constraints

The number of nodes in the list is n
1 ≤ k ≤ n ≤ 5000
0 ≤ Node.val ≤ 1000
Follow-up: Can you solve the problem in O(1) extra memory space?

Visualization

Tap to expand

Understanding the Visualization

Identify Team Size

Count k workers to form a complete team

Reverse Team Direction

Have each complete team face the opposite direction

Maintain Line Connection

Ensure teams remain connected in the assembly line

Handle Incomplete Team

Leave remaining workers (< k) in original direction

Key Takeaway

🎯 Key Insight: Process the linked list systematically by identifying complete groups of k nodes, reversing each group in-place through pointer manipulation, and maintaining proper connections between groups for an optimal O(n) time, O(1) space solution.

Asked in

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

The optimal solution uses in-place pointer manipulation to reverse each complete group of k nodes in O(n) time and O(1) space. The key insight is to process the list in chunks, checking for complete groups and reversing only when we have exactly k nodes available.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Approach (Multiple Passes)	O(n)	O(n)	Convert to array, reverse in groups, rebuild list
Iterative In-Place Reversal (Optimal)	O(n)	O(1)	Reverse each group of k nodes in-place using pointer manipulation

Naive Approach (Multiple Passes) — Algorithm Steps

Traverse the linked list and store all values in an array
Reverse array elements in groups of k
Create a new linked list from the modified array
Return the head of the new list

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Extract all values from linked list into array

Identify Groups

Mark complete groups of k elements

Reverse Groups

Reverse each complete group in the array

Rebuild List

Create new linked list from modified array

Code -

solution.c — C

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* reverseKGroup(struct ListNode* head, int k) {
    if (!head || k == 1) return head;
    
    // Count nodes
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        count++;
        curr = curr->next;
    }
    
    // Convert to array
    int* values = (int*)malloc(count * sizeof(int));
    curr = head;
    for (int i = 0; i < count; i++) {
        values[i] = curr->val;
        curr = curr->next;
    }
    
    // Reverse in groups of k
    for (int i = 0; i < count - count % k; i += k) {
        int left = i, right = i + k - 1;
        while (left < right) {
            int temp = values[left];
            values[left] = values[right];
            values[right] = temp;
            left++;
            right--;
        }
    }
    
    // Rebuild linked list
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    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;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    free(values);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three passes: one to build array, one to reverse groups, one to rebuild list

✓ Linear Growth

Space Complexity

O(n)

Extra array to store all node values

⚡ Linearithmic Space

89.3K Views

High Frequency

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

Naive Approach (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler