Reverse given Linked List in groups of specific given sizes
Last Updated :
13 Jun, 2022
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->5->6->7->8->9, arr[] = {2, 3, 3}
Output: 2->1->5->4->3->8->7->6->9
Explanation: The first group of size 2 is 1->2. Upon reversing it becomes 2->1.
The next group of size 3 is 3->4->5 which on reversing becomes 5->4->3.
The last group of size 3 is 6->7->8 which on reversing becomes 8->7->6.
Input: head = 6->8->7, arr[] = {1, 2}
Output: 6->7->8
Approach: The solution to the problem is based on the idea of selecting groups of nodes of arr[i] size and considering each sublist as an individual linked list and using the concept of reversing a linked list.
Follow the illustration below for a better understanding:
Illustration:
reverse(head, arr, n, index)
Follow the steps mentioned below to implement the idea:
- Traverse through the array from i = 0 to N:
- Reverse the sub-list of size arr[i].
- While reversing the sub-list, for each node, interchange the pointers pointing to the next node and the previous node.
- If the end of the array is reached, stop iteration and return the head pointer of the final list.
Below is the implementation of the above approach.
C++
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
// Structure of a Binary Tree Node
struct Node {
int data;
Node* next;
Node(int d)
{
data = d;
next = NULL;
}
};
struct LinkedList {
Node* head;
LinkedList() { head = NULL; }
// Function to reverse a node
Node* reverse(Node* head, int arr[], int size, int index)
{
if (head == NULL)
return NULL;
Node* current = head;
Node* next = NULL;
Node* prev = NULL;
int count = 0;
while (current != NULL && index < size
&& count < arr[index]) {
next = current->next;
current->next = prev;
prev = current;
current = next;
count++;
}
if (index >= size) {
while (current != NULL) {
next = current->next;
current->next = prev;
prev = current;
current = next;
count++;
}
}
if (next != NULL) {
head->next = reverse(next, arr, size, index + 1);
}
return prev;
}
// Function to push a node
void push(int new_data)
{
Node* new_node = new Node(new_data);
new_node->next = head;
head = new_node;
}
// Function to print list
void printList()
{
Node* temp = head;
while (temp != NULL) {
cout << temp->data << "->";
temp = temp->next;
}
cout << endl;
}
};
// Driver program
int main()
{
LinkedList llist;
int arr[] = { 2, 3, 3 };
int size = sizeof(arr)/sizeof(arr[0]);
llist.push(9);
llist.push(8);
llist.push(7);
llist.push(6);
llist.push(5);
llist.push(4);
llist.push(3);
llist.push(2);
llist.push(1);
llist.head
= llist.reverse(llist.head, arr, size, 0);
llist.printList();
return 0;
}
// This code is contributed by jana_sayantan.
// Java code to implement the approach
import java.io.*;
public class LinkedList {
Node head;
// Node Class
static class Node {
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
// Function to reverse a node
Node reverse(Node head, int[] arr, int size, int index)
{
if (head == null)
return null;
Node current = head;
Node next = null;
Node prev = null;
int count = 0;
while (current != null && index < size
&& count < arr[index]) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
if (index >= size) {
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
}
if (next != null) {
head.next = reverse(next, arr, size, index + 1);
}
return prev;
}
// Function to push a node
public void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// Function to print list
void printList()
{
Node temp = head;
while (temp != null) {
System.out.print(temp.data + "->");
temp = temp.next;
}
System.out.println();
}
// Driver code
public static void main(String[] args)
{
LinkedList llist = new LinkedList();
int[] arr = { 2, 3, 3 };
int size = arr.length;
llist.push(9);
llist.push(8);
llist.push(7);
llist.push(6);
llist.push(5);
llist.push(4);
llist.push(3);
llist.push(2);
llist.push(1);
llist.head
= llist.reverse(llist.head, arr, size, 0);
llist.printList();
}
}
// This code is contributed by karandeep123.
# Python code for the above approach
# Node Class
class Node:
def __init__(self, d):
self.data = d
self.next = None
class LinkedList:
def __init__(self):
self.head = None
## Function to push a node
def push(self, new_data):
new_node = Node(new_data);
new_node.next = self.head;
self.head = new_node;
## Function to print list
def printList(self):
temp = self.head
while temp != None:
print(temp.data, end='')
if temp.next != None:
print("->", end='')
temp = temp.next
print("\n")
## Function to reverse a node
def reverse(self, head, arr, size, index):
if (head == None):
return None
current = head
next = None
prev = None
count = 0
while current != None and index < size and count < arr[index]:
next = current.next
current.next = prev
prev = current
current = next
count+=1
if (index >= size):
while current != None:
next = current.next
current.next = prev
prev = current
current = next
count+=1
if next != None:
head.next = self.reverse(next, arr, size, index + 1);
return prev;
# Driver Code
if __name__=='__main__':
llist = LinkedList()
arr = [2, 3, 3]
size = len(arr)
llist.push(9)
llist.push(8)
llist.push(7)
llist.push(6)
llist.push(5)
llist.push(4)
llist.push(3)
llist.push(2)
llist.push(1)
llist.head = llist.reverse(llist.head, arr, size, 0)
llist.printList()
# This code is contributed by subhamgoyal2014.
// C# code to implement the approach
using System;
using System.Linq;
public class LinkedList {
Node head;
// Node Class
class Node {
public int data;
public Node next;
public Node(int d)
{
data = d;
next = null;
}
}
// Function to reverse a node
Node reverse(Node head, int[] arr,
int size, int index)
{
if (head == null)
return null;
Node current = head;
Node next = null;
Node prev = null;
int count = 0;
while (current != null
&& index < size
&& count < arr[index]) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
if (index >= size) {
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
}
if (next != null) {
head.next
= reverse(next, arr,
size, index + 1);
}
return prev;
}
// Function to push a node
public void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// Function to print list
void printList()
{
Node temp = head;
while (temp != null) {
Console.Write(temp.data + "->");
temp = temp.next;
}
Console.WriteLine();
}
// Driver code
static void Main()
{
LinkedList llist = new LinkedList();
int[] arr = { 2, 3, 3 };
int size = arr.Count();
llist.push(9);
llist.push(8);
llist.push(7);
llist.push(6);
llist.push(5);
llist.push(4);
llist.push(3);
llist.push(2);
llist.push(1);
llist.head
= llist.reverse(llist.head,
arr, size, 0);
llist.printList();
}
}
// This code is contributed by Karandeep1234
// Javascript code to implement the approach
// Structure of a Binary Tree Node
class Node {
constructor(d)
{
this.data = d;
this.next = null;
}
};
// Function to reverse a node
function reverse(head,arr,size,index)
{
if (head == null)
return null;
let current = head;
let next = null;
let prev = null;
let count = 0;
while (current != null && index < size
&& count < arr[index]) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
if (index >= size) {
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
count++;
}
}
if (next != null) {
head.next = reverse(next, arr, size, index + 1);
}
return prev;
}
class LinkedList {
constructor() { this.head = null; }
// Function to push a node
push(new_data)
{
let new_node = new Node(new_data);
new_node.next = this.head;
this.head = new_node;
}
// Function to print list
printList() {
var curr = this.head;
var str = "";
while (curr) {
str += curr.data + "->";
curr = curr.next;
}
console.log(str);
}
}
// Driver program
let llist= new LinkedList();
let arr = [ 2, 3, 3 ];
let size = 3;
llist.push(9);
llist.push(8);
llist.push(7);
llist.push(6);
llist.push(5);
llist.push(4);
llist.push(3);
llist.push(2);
llist.push(1);
llist.head
= reverse(llist.head, arr, size, 0);
llist.printList();
// This code is contributed by Ishan Khandelwal.
Output2->1->5->4->3->8->7->6->9->
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
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 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
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 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
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
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 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 singly Linked List in groups of given size (Recursive 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.Example: Input: head: 1 -> 2 -> 3 -> 4 -> 5 ->
9 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