Reverse a Linked List in groups of a Given Size using C++

In this article, we deal with a singly linked list, and the task is to reverse the list in groups of k. For example −

Input: 1->2->3->4->5->6->7->8->NULL, K = 3
Output: 3->2->1->6->5->4->8->7->NULL

Input: 1->2->3->4->5->6->7->8->NULL, K = 5
Output: 5->4->3->2->1->8

For this problem, one approach that comes to mind is trailing the list and reversing the list when our sublist’s size reaches k and continues.

Approach to find The Solution

In this approach, we will generally traverse through the list and keep a counter to count the number of elements in our sub-list. When the counter reaches the count of k, we reverse that part.


#include <bits/stdc++.h>
using namespace std;
class Node {
   int data;
   Node* next;
Node* reverse(Node* head, int k) {
   if (!head)
      return NULL;
   Node* curr = head;
   Node* next = NULL;
   Node* prev = NULL;
   int count = 0;
   while (curr != NULL && count < k) { // we reverse the list till our count is less than k
      next = curr->next;
      curr->next = prev;
      prev = curr;
      curr = next;
   if (next != NULL) // if our link list has not ended we call reverse function again
      head->next = reverse(next, k);
   return prev;
void push(Node** head_ref, int new_data) { // function for pushing data in the list
   Node* new_node = new Node();
   new_node->data = new_data;
   new_node->next = (*head_ref);
   (*head_ref) = new_node;
void printList(Node* node) { // function to print linked list

   while (node != NULL) {
      cout << node->data << " ";
      node = node->next;
   cout << "\n";
int main() {
   Node* head = NULL;

   int k = 3; // the given k

   push(&head, 8);
   push(&head, 7);
   push(&head, 6);
   push(&head, 5);
   push(&head, 4);
   push(&head, 3);
   push(&head, 2);
   push(&head, 1);

   cout << "Original list \n";

   head = reverse(head, k); // this function will return us our new head
   cout << "New list \n";
   return (0);


Original list
1 2 3 4 5 6 7 8
New list
3 2 1 6 5 4 8 7

The above approach has a time complexity of O(N), where N is the size of our given list, and this approach works on recursion. This approach can work for higher constraints as well.

Explanation of the above code

We will traverse through the array in this approach and keep reversing it till our counter variable is less than k. When our counter reaches the value of k, we call another reversing function to connect the last node of this sub-list to the first node of the next reversed sub-list. This is being done by recursion.


In this article, we solve a problem to Reverse a Linked List in groups of a given size using recursion. We also learned the C++ program for this problem and the complete approach ( Normal) by which we solved this problem. We can write the same program in other languages such as C, java, python, and other languages. We hope you find this article helpful.