Reverse a singly Linked List in groups of given size (Recursive Approach)
Last Updated :
12 Sep, 2024
Given a Singly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should be considered as a group and must be reversed.
Example:
Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL, k = 2
Output: head: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> NULL
Explanation : Linked List is reversed in a group of size k = 2.
Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL, k = 4
Output: head: 4 -> 3 -> 2 -> 1 -> 6 -> 5 -> NULL
Explanation : Linked List is reversed in a group of size k = 4.
Approach:
The idea is to reverse the first k nodes of the list and update the head of the list to the new head of this reversed segment. Then, connect the tail of this reversed segment to the result of recursively reversing the remaining portion of the list.
Follow the steps below to solve the problem:
- If the list is empty, return the head.
- Reverse the first k nodes using the reverseKNodes() function and update the new Head with the reversed list head.
- Connect the tail of the reversed group to the result of recursively reversing the remaining list using the reverseKGroup() function.
- Update next pointers during the reversal.
- At last, return the new Head of the reversed list from the first group.
Below is the implementation of the above approach:
C++
// C++ code to reverse a singly linked
// list in groups of K size
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *next;
Node(int x) {
data = x;
next = nullptr;
}
};
// Helper function to reverse K nodes
Node *reverseKNodes(Node *head, int k) {
Node *curr = head, *prev = nullptr, *next = nullptr;
int count = 0;
while (curr != nullptr && count < k) {
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
count++;
}
return prev;
}
// Recursive function to reverse in groups of K
Node *reverseKGroup(Node *head, int k) {
if (head == nullptr) {
return head;
}
Node *groupHead = nullptr;
Node *newHead = nullptr;
// Move temp to the next group
Node *temp = head;
int count = 0;
while (temp && count < k) {
temp = temp->next;
count++;
}
// Reverse the first K nodes
groupHead = reverseKNodes(head, k);
// Connect the reversed group with the next part
if (newHead == nullptr) {
newHead = groupHead;
}
// Recursion for the next group
head->next = reverseKGroup(temp, k);
return newHead;
}
void printList(Node *head) {
Node *curr = head;
while (curr != nullptr) {
cout << curr->data << " ";
curr = curr->next;
}
cout << endl;
}
int main() {
// Creating a sample singly linked list:
// 1 -> 2 -> 3 -> 4 -> 5 -> 6
Node *head = new Node(1);
head->next = new Node(2);
head->next->next = new Node(3);
head->next->next->next = new Node(4);
head->next->next->next->next = new Node(5);
head->next->next->next->next->next = new Node(6);
head = reverseKGroup(head, 3);
printList(head);
return 0;
}
// C program to reverse a linked list in groups of given size
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
// Helper function to reverse K nodes
struct Node* reverseKNodes(struct Node* head, int k) {
struct Node* curr = head;
struct Node* prev = NULL;
struct Node* next = NULL;
int count = 0;
while (curr != NULL && count < k) {
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
count++;
}
return prev;
}
// Recursive function to reverse in groups of K
struct Node* reverseKGroup(struct Node* head, int k) {
if (head == NULL) {
return head;
}
struct Node* temp = head;
int count = 0;
while (temp != NULL && count < k) {
temp = temp->next;
count++;
}
struct Node* groupHead = reverseKNodes(head, k);
// Recursion for the next group
head->next = reverseKGroup(temp, k);
return groupHead;
}
void printList(struct Node* head) {
struct Node* curr = head;
while (curr != NULL) {
printf("%d ", curr->data);
curr = curr->next;
}
printf("\n");
}
struct Node* createNode(int x) {
struct Node* newNode =
(struct Node*)malloc(sizeof(struct Node));
newNode->data = x;
newNode->next = NULL;
return newNode;
}
int main() {
// Creating a sample singly linked list:
// 1 -> 2 -> 3 -> 4 -> 5 -> 6
struct Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
head->next->next->next->next->next = createNode(6);
head = reverseKGroup(head, 3);
printList(head);
return 0;
}
// Java program to reverse a linked list in groups of
// given size
class Node {
int data;
Node next;
Node(int x) {
data = x;
next = null;
}
}
// Helper function to reverse K nodes
class GfG {
static Node reverseKNodes(Node head, int k) {
Node curr = head;
Node prev = null;
Node next = null;
int count = 0;
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
count++;
}
return prev;
}
// Recursive function to reverse in groups of K
static Node reverseKGroup(Node head, int k) {
if (head == null) {
return head;
}
Node temp = head;
int count = 0;
while (temp != null && count < k) {
temp = temp.next;
count++;
}
Node groupHead = reverseKNodes(head, k);
// Recursion for the next group
head.next = reverseKGroup(temp, k);
return groupHead;
}
static void printList(Node head) {
Node curr = head;
while (curr != null) {
System.out.print(curr.data + " ");
curr = curr.next;
}
System.out.println();
}
public static void main(String[] args) {
// Creating a sample singly linked list:
// 1 -> 2 -> 3 -> 4 -> 5 -> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head.next.next.next.next.next = new Node(6);
head = reverseKGroup(head, 3);
printList(head);
}
}
# Python program to reverse a
# linked list in group of given size
class Node:
def __init__(self, x):
self.data = x
self.next = None
# Helper function to reverse K nodes
def reverseKNodes(head, k):
curr = head
prev = None
next = None
count = 0
while curr is not None and count < k:
next = curr.next
curr.next = prev
prev = curr
curr = next
count += 1
return prev
# Recursive function to reverse in groups of K
def reverseKGroup(head, k):
if head is None:
return head
temp = head
count = 0
while temp is not None and count < k:
temp = temp.next
count += 1
groupHead = reverseKNodes(head, k)
# Recursion for the next group
head.next = reverseKGroup(temp, k)
return groupHead
def printList(head):
curr = head
while curr is not None:
print(curr.data, end=" ")
curr = curr.next
print()
if __name__ == "__main__":
# Creating a sample singly linked list:
# 1 -> 2 -> 3 -> 4 -> 5 -> 6
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)
head.next.next.next.next.next = Node(6)
head = reverseKGroup(head, 3)
printList(head)
// C# program to reverse a linked list
// in groups of given size
using System;
class Node {
public int data;
public Node next;
public Node(int x) {
data = x;
next = null;
}
}
class GfG {
// Helper function to reverse K nodes
static Node reverseKNodes(Node head, int k) {
Node curr = head;
Node prev = null;
Node next = null;
int count = 0;
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
count++;
}
return prev;
}
// Recursive function to reverse in groups of K
static Node reverseKGroup(Node head, int k) {
if (head == null) {
return head;
}
Node temp = head;
int count = 0;
while (temp != null && count < k) {
temp = temp.next;
count++;
}
Node groupHead = reverseKNodes(head, k);
// Recursion for the next group
head.next = reverseKGroup(temp, k);
return groupHead;
}
static void printList(Node head) {
Node curr = head;
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
static void Main(string[] args) {
// Creating a sample singly linked list:
// 1 -> 2 -> 3 -> 4 -> 5 -> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head.next.next.next.next.next = new Node(6);
head = reverseKGroup(head, 3);
printList(head);
}
}
// Javascript program to reverse a
// linked list in groups of
// given size
class Node {
constructor(x) {
this.data = x;
this.next = null;
}
}
// Helper function to reverse K nodes
function reverseKNodes(head, k) {
let curr = head;
let prev = null;
let next = null;
let count = 0;
while (curr !== null && count < k) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
count++;
}
return prev;
}
// Recursive function to reverse in groups of K
function reverseKGroup(head, k) {
if (head === null) {
return head;
}
let temp = head;
let count = 0;
while (temp !== null && count < k) {
temp = temp.next;
count++;
}
let groupHead = reverseKNodes(head, k);
// Recursion for the next group
head.next = reverseKGroup(temp, k);
return groupHead;
}
function printList(head) {
let curr = head;
while (curr !== null) {
console.log(curr.data + " ");
curr = curr.next;
}
}
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head.next.next.next.next.next = new Node(6);
head = reverseKGroup(head, 3);
printList(head);
Time complexity: O(n), where n is the number of nodes in linked list.
Auxiliary Space: O(n / k)
Related articles:
Similar Reads
Reverse a Linked List in groups of given size (Iterative Approach) Given a Singly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should be considered as a group and must be reversed.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> 5 ->
10 min read
Reverse a Linked List in groups of given size Given a Singly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should be considered as a group and must be reversed.Example: Input: head: 1 -> 2 -> 3 -> 4 -> 5 ->
3 min read
Reverse a doubly linked list in groups of given size | Set 2 Given a doubly-linked list containing n nodes. The problem is to reverse every group of k nodes in the list. Examples: Input: List: 10<->8<->4<->2, K=2Output: 8<->10<->2<->4 Input: List: 1<->2<->3<->4<->5<->6<->7<->8, K=3O
15+ min read
Reverse a Linked List in groups of given size using Deque Given a Singly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should be considered as a group and must be reversed.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> 5 ->
8 min read
Reverse a Linked List in groups of given size using Stack Given a Singly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should be considered as a group and must be reversed.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> 5 ->
8 min read
Javascript Program For Reversing A Linked List In Groups Of Given Size - Set 1 Given a linked list, write a function to reverse every k nodes (where k is an input to the function). 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,
3 min read
Javascript Program For Reversing A Linked List In Groups Of Given Size- Set 2 Given a linked list, write a function to reverse every k nodes (where k is an input to the function). Examples:Input: 1->2->3->4->5->6->7->8->NULL and k = 3 Output: 3->2->1->6->5->4->8->7->NULL. Input: 1->2->3->4->5->6->7->8->NU
3 min read
Reverse a doubly linked list in groups of K size Given a Doubly linked list containing n nodes. The task is to reverse every group of k nodes in the list. If the number of nodes is not a multiple of k then left-out nodes, in the end should be considered as a group and must be reversed.Examples: Input: 1 <-> 2 <-> 3 <-> 4 <-
15+ min read
Reverse given Linked List in groups of specific given sizes Given the linked list and an array arr[] of size N, the task is to reverse every arr[i] nodes of the list at a time (0 ≤ i < N). Note: If the number of nodes in the list is greater than the sum of array, then the remaining nodes will remain as it is. Examples: Input: head = 1->2->3->4-
8 min read
XOR Linked List - Reverse a Linked List in groups of given size Given a XOR linked list and an integer K, the task is to reverse every K nodes in the given XOR linked list. Examples: Input: XLL = 7< – > 6 < – > 8 < – > 11 < – > 3, K = 3 Output: 8 < – > 6 < – > 7 < – > 3 < – > 11 Explanation: Reversing first K(= 3)
13 min read