# Reverse a Linked List in groups of given size using C++ program

In this article, we are going to learn how to reverse a liked list in groups of given size? This article contains problem statement, explanation, algorithm, C++ implementation and output.
By Souvik Saha Last updated : August 01, 2023

## Problem statement

Given a linked list of size N. The task is to reverse every k nodes in the linked list.

Consider the below example with sample input and output:

```If a linked listis: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8
The value of k is 2
Then the linked list looks like: 2 → 1 → 4 → 3 → 6 → 5 → 8 → 7
```

## Algorithm

To solve the problem we follow this algorithm,

There is a function named as Reverse(start_node, k) and it reverses the k nodes from the start_node and every time it returns a starting node of that group.

1. We store the next pointer into node variable and connect the current pointer to the head of another node variable name as prev.
2. In the reverse list head node of the linkedlist will come to the tail and we connect the next node to next pointer of the head.

## Pseudo Code

```head->next=Reverse(start->node,k)
Reverse function:

//base case
return NULL;
}

//declarations
struct node* next=NULL;
struct node* prev=NULL;
int count=0;
while(curr&& count<k){
//we store the next pointer into next
//and connect the  current pointer to the head of the prev
next=curr->next;
curr->next=prev;
prev=curr;
curr=next;
count++;
}
//in the reverse list head node of the linked list will come to the tail
//for this we connect the next node to it's next pointer

return prev;
```

## C++ program to reverse a linked list in groups of given size

```#include <bits/stdc++.h>
using namespace std;

struct node {
int data;
node* next;
};

//Create a new node
struct node* create_node(int x)
{
struct node* temp = new node;
temp->data = x;
temp->next = NULL;
return temp;
}

//Enter the node into the linked list
{
struct node* store = create_node(x);
return;
}
while (temp->next) {
temp = temp->next;
}
temp->next = store;
}

struct node* reverse(node* head, int k)
{
return NULL;
}
struct node* next = NULL;
struct node* prev = NULL;
int count = 0;

while (curr && count < k) {
//we store the next pointer into next
//and connect the  current pointer to the head of the prev
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
count++;
}

//in the reverse list head node of the linkedlist will come to the tail
//for this we connect the next node to it's next pointer
return prev;
}

//Print the list
{
while (temp) {
cout << temp->data << " ";
temp = temp->next;
}
}

int main()
{
struct node* l = NULL;

push(&l, 1);
push(&l, 2);
push(&l, 3);
push(&l, 4);
push(&l, 5);
push(&l, 6);

cout << "Before the reverse operation" << endl;
print(l);

l = reverse(l, 2);

cout << "\nAfter the reverse operation" << endl;
print(l);

return 0;
}
```

## Output

```Before the reverse operation
1 2 3 4 5 6
After the reverse operation
2 1 4 3 6 5
```