Reverse a doubly linked list in groups of K size
Last Updated :
07 Sep, 2024
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 <-> 5 <-> 6 <-> NULL, k = 2
Output: 2 <-> 1 <-> 4 <-> 3 <-> 6 <-> 5 <-> NULL.
Explanation : Linked List is reversed in a group of size k = 2.
Input: 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6 <-> NULL, k = 4
Output: 4 <-> 3 <-> 2 <-> 1 <-> 6 -> 5 -> NULL.
Explanation : Linked List is reversed in a group of size k = 4.
[Expected Approach – 1] Using Recursion – O(n) Time and O(n) Space:
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 and prev pointers during the reversal.
- At last, return the new Head of the reversed list from the first group.
C++
// C++ code to reverse a doubly linkedÂ
// list in groups of K size
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *next;
Node *prev;
Node(int x) {
data = x;
next = nullptr;
prev = 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;
curr->prev = nullptr;
if (prev != nullptr) {
prev->prev = curr;
}
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);
if (head->next != nullptr) {
head->next->prev = head;
}
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 doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node *head = new Node(1);
head->next = new Node(2);
head->next->prev = head;
head->next->next = new Node(3);
head->next->next->prev = head->next;
head->next->next->next = new Node(4);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = new Node(5);
head->next->next->next->next->prev = head->next->next->next;
head->next->next->next->next->next = new Node(6);
head->next->next->next->next->next->prev = head->next->next->next->next;
head = reverseKGroup(head, 2);
printList(head);
return 0;
}
// C code to reverse a doubly linked
// list in groups of K size
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
struct Node* prev;
};
// 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;
curr->prev = NULL;
if (prev != NULL) {
prev->prev = curr;
}
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* groupHead = NULL;
struct Node* newHead = NULL;
// Move temp to the next group
struct 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 == NULL) {
newHead = groupHead;
}
// Recursion for the next group
head->next = reverseKGroup(temp, k);
if (head->next != NULL) {
head->next->prev = head;
}
return newHead;
}
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 data) {
struct Node* newNode =
(struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
newNode->prev = NULL;
return newNode;
}
int main() {
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
struct Node* head = createNode(1);
head->next = createNode(2);
head->next->prev = head;
head->next->next = createNode(3);
head->next->next->prev = head->next;
head->next->next->next = createNode(4);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = createNode(5);
head->next->next->next->next->prev = head->next->next->next;
head->next->next->next->next->next = createNode(6);
head->next->next->next->next->next->prev = head->next->next->next->next;
head = reverseKGroup(head, 2);
printList(head);
return 0;
}
// Java code to reverse a doubly linked
// list in groups of K size
class Node {
int data;
Node next;
Node prev;
Node(int x) {
data = x;
next = null;
prev = null;
}
}
// Helper function to reverse K nodes
class GfG {
static Node reverseKNodes(Node head, int k) {
Node curr = head, prev = null, next = null;
int count = 0;
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev != null) {
prev.prev = curr;
}
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 groupHead = null;
Node newHead = null;
// Move temp to the next group
Node temp = head;
int count = 0;
while (temp != null && 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 == null) {
newHead = groupHead;
}
// Recursion for the next group
head.next = reverseKGroup(temp, k);
if (head.next != null) {
head.next.prev = head;
}
return newHead;
}
// Function to print the doubly linked list
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 doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
}
}
# Python code to reverse a doubly linked
# list in groups of K size
class Node:
def __init__(self, data):
self.data = data
self.next = None
self.prev = 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
curr.prev = None
if prev is not None:
prev.prev = curr
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
groupHead = None
newHead = None
# Move temp to the next group
temp = head
count = 0
while temp and count < k:
temp = temp.next
count += 1
# Reverse the first K nodes
groupHead = reverseKNodes(head, k)
# Connect the reversed group with the next part
if newHead is None:
newHead = groupHead
# Recursion for the next group
head.next = reverseKGroup(temp, k)
if head.next is not None:
head.next.prev = head
return newHead
def printList(head):
curr = head
while curr is not None:
print(curr.data, end=" ")
curr = curr.next
print()
if __name__ == "__main__":
# Creating a sample doubly linked list:
# 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
head = Node(1)
head.next = Node(2)
head.next.prev = head
head.next.next = Node(3)
head.next.next.prev = head.next
head.next.next.next = Node(4)
head.next.next.next.prev = head.next.next
head.next.next.next.next = Node(5)
head.next.next.next.next.prev = head.next.next.next
head.next.next.next.next.next = Node(6)
head.next.next.next.next.next.prev = head.next.next.next.next
head = reverseKGroup(head, 2)
printList(head)
// C# code to reverse a doubly linked
// list in groups of K size
using System;
class Node {
public int data;
public Node next;
public Node prev;
public Node(int x) {
data = x;
next = null;
prev = null;
}
}
// Helper function to reverse K nodes
class GfG {
static Node reverseKNodes(Node head, int k) {
Node curr = head, prev = null, next = null;
int count = 0;
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev != null) {
prev.prev = curr;
}
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 groupHead = null;
Node newHead = null;
// Move temp to the next group
Node temp = head;
int count = 0;
while (temp != null && 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 == null) {
newHead = groupHead;
}
// Recursion for the next group
head.next = reverseKGroup(temp, k);
if (head.next != null) {
head.next.prev = head;
}
return newHead;
}
static void printList(Node head) {
Node curr = head;
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
static void Main() {
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
}
}
// JavaScript code to reverse a doubly linked
// list in groups of K size
class Node {
constructor(data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
// Helper function to reverse K nodes
function reverseKNodes(head, k) {
let curr = head, prev = null, next = null;
let count = 0;
while (curr !== null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev !== null) {
prev.prev = curr;
}
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 groupHead = null;
let newHead = null;
// Move temp to the next group
let temp = head;
let 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 === null) {
newHead = groupHead;
}
// Recursion for the next group
head.next = reverseKGroup(temp, k);
if (head.next !== null) {
head.next.prev = head;
}
return newHead;
}
function printList(head) {
let curr = head;
while (curr !== null) {
console.log(curr.data + " ");
curr = curr.next;
}
console.log();
}
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
let head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
Time complexity: O(n), where n is the number of nodes in linked list.
Auxiliary Space: O(n)
[Expected Approach – 2] Using Iterative Method – O(n) Time and O(1) Space:
The idea is to traverse the list in groups of k nodes, reversing each group. After reversing a group, link it to the previous group by updating the tail pointer. Continue until the entire list is traversed and return the new head.
Follow the steps below to solve the problem:
- Initialize pointers curr to traverse the list, newHead to track the new head of the list, tail to connect the previous group to the current group.
- For each group of k nodes:
- Set groupHead to the current node.
- Then, reverse the group of k nodes by updating next and prev pointers.
- Also, keep track of the prev node (which will be the new head of the reversed group) and the next node (which is the start of the next group).
- Connect the end of the previous group to the start of the current reversed group.
- Repeat the process for the remaining nodes in the list until all nodes are traversed.
Below is the implementation of the above approach:
C++
// C++ code to reverse a doubly linked
// list in groups of K size
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *next;
Node *prev;
Node(int x) {
data = x;
next = nullptr;
prev = nullptr;
}
};
// Helper function to reverse K nodes iteratively
Node *reverseKGroup(Node *head, int k) {
if (head == nullptr) {
return head;
}
Node *curr = head;
Node *newHead = nullptr;
Node *tail = nullptr;
while (curr != nullptr) {
Node *groupHead = curr;
Node *prev = nullptr;
Node *next = nullptr;
int count = 0;
// Reverse the nodes in the current group
while (curr != nullptr && count < k) {
next = curr->next;
curr->next = prev;
curr->prev = nullptr;
if (prev != nullptr) {
prev->prev = curr;
}
prev = curr;
curr = next;
count++;
}
// If newHead is null, set it to the
// last node of the first group
if (newHead == nullptr) {
newHead = prev;
}
// Connect the previous group to the
// current reversed group
if (tail != nullptr) {
tail->next = prev;
prev->prev = tail;
}
// Move tail to the end of the reversed group
tail = groupHead;
}
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 doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node *head = new Node(1);
head->next = new Node(2);
head->next->prev = head;
head->next->next = new Node(3);
head->next->next->prev = head->next;
head->next->next->next = new Node(4);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = new Node(5);
head->next->next->next->next->prev = head->next->next->next;
head->next->next->next->next->next = new Node(6);
head->next->next->next->next->next->prev = head->next->next->next->next;
head = reverseKGroup(head, 2);
printList(head);
return 0;
}
// C code to reverse a doubly linked
// list in groups of K size
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
struct Node* prev;
};
// Helper function to reverse K nodes iteratively
struct Node* reverseKGroup(struct Node* head, int k) {
if (head == NULL) {
return head;
}
struct Node* curr = head;
struct Node* newHead = NULL;
struct Node* tail = NULL;
while (curr != NULL) {
struct Node* groupHead = curr;
struct Node* prev = NULL;
struct Node* next = NULL;
int count = 0;
// Reverse the nodes in the current group
while (curr != NULL && count < k) {
next = curr->next;
curr->next = prev;
curr->prev = NULL;
if (prev != NULL) {
prev->prev = curr;
}
prev = curr;
curr = next;
count++;
}
// If newHead is null, set it to the
// last node of the first group
if (newHead == NULL) {
newHead = prev;
}
// Connect the previous group
// to the current reversed group
if (tail != NULL) {
tail->next = prev;
prev->prev = tail;
}
// Move tail to the end of
// the reversed group
tail = groupHead;
}
return newHead;
}
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 data) {
struct Node* newNode =
(struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
newNode->prev = NULL;
return newNode;
}
int main() {
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
struct Node* head = createNode(1);
head->next = createNode(2);
head->next->prev = head;
head->next->next = createNode(3);
head->next->next->prev = head->next;
head->next->next->next = createNode(4);
head->next->next->next->prev = head->next->next;
head->next->next->next->next = createNode(5);
head->next->next->next->next->prev = head->next->next->next;
head->next->next->next->next->next = createNode(6);
head->next->next->next->next->next->prev = head->next->next->next->next;
head = reverseKGroup(head, 2);
printList(head);
return 0;
}
// Java code to reverse a doubly linked
// list in groups of K size
class Node {
int data;
Node next;
Node prev;
Node(int x) {
data = x;
next = null;
prev = null;
}
}
// Helper function to reverse K nodes iteratively
class GfG {
public static Node reverseKGroup(Node head, int k) {
if (head == null) {
return head;
}
Node curr = head;
Node newHead = null;
Node tail = null;
while (curr != null) {
Node groupHead = curr;
Node prev = null;
Node next = null;
int count = 0;
// Reverse the nodes in the current group
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev != null) {
prev.prev = curr;
}
prev = curr;
curr = next;
count++;
}
// If newHead is null, set it to the
// last node of the first group
if (newHead == null) {
newHead = prev;
}
// Connect the previous group to the
// current reversed group
if (tail != null) {
tail.next = prev;
prev.prev = tail;
}
// Move tail to the end of the
//reversed group
tail = groupHead;
}
return newHead;
}
// Function to print the doubly linked list
public 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 doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
}
}
# Python code to reverse a doubly linked
# list in groups of K size
class Node:
def __init__(self, x):
self.data = x
self.next = None
self.prev = None
# Helper function to reverse K nodes iteratively
def reverseKGroup(head, k):
if head is None:
return head
curr = head
newHead = None
tail = None
while curr is not None:
groupHead = curr
prev = None
next_node = None
count = 0
# Reverse the nodes in the current group
while curr is not None and count < k:
next_node = curr.next
curr.next = prev
curr.prev = None
if prev is not None:
prev.prev = curr
prev = curr
curr = next_node
count += 1
# If newHead is null, set it to the last
# node of the first group
if newHead is None:
newHead = prev
# Connect the previous group to the
# current reversed group
if tail is not None:
tail.next = prev
prev.prev = tail
# Move tail to the end of the reversed group
tail = groupHead
return newHead
def printList(head):
curr = head
while curr is not None:
print(curr.data, end=" ")
curr = curr.next
print()
if __name__ == "__main__":
# Creating a sample doubly linked list:
# 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
head = Node(1)
head.next = Node(2)
head.next.prev = head
head.next.next = Node(3)
head.next.next.prev = head.next
head.next.next.next = Node(4)
head.next.next.next.prev = head.next.next
head.next.next.next.next = Node(5)
head.next.next.next.next.prev = head.next.next.next
head.next.next.next.next.next = Node(6)
head.next.next.next.next.next.prev = head.next.next.next.next
head = reverseKGroup(head, 2)
printList(head)
// C# code to reverse a doubly linked
// list in groups of K size
using System;
class Node {
public int data;
public Node next;
public Node prev;
public Node(int x) {
data = x;
next = null;
prev = null;
}
}
// Helper function to reverse K nodes iteratively
class GFG {
static Node reverseKGroup(Node head, int k) {
if (head == null) {
return head;
}
Node curr = head;
Node newHead = null;
Node tail = null;
while (curr != null) {
Node groupHead = curr;
Node prev = null;
Node next = null;
int count = 0;
// Reverse the nodes in the current group
while (curr != null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev != null) {
prev.prev = curr;
}
prev = curr;
curr = next;
count++;
}
// If newHead is null, set it to the
// last node of the first group
if (newHead == null) {
newHead = prev;
}
// Connect the previous group to the
// current reversed group
if (tail != null) {
tail.next = prev;
prev.prev = tail;
}
// Move tail to the end of the reversed group
tail = groupHead;
}
return newHead;
}
static void printList(Node head) {
Node curr = head;
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
static void Main() {
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
Node head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
}
}
// JavaScript code to reverse a doubly linked
// list in groups of K size
class Node {
constructor(x) {
this.data = x;
this.next = null;
this.prev = null;
}
}
// Helper function to reverse K nodes iteratively
function reverseKGroup(head, k) {
if (head === null) {
return head;
}
let curr = head;
let newHead = null;
let tail = null;
while (curr !== null) {
let groupHead = curr;
let prev = null;
let next = null;
let count = 0;
// Reverse the nodes in the current group
while (curr !== null && count < k) {
next = curr.next;
curr.next = prev;
curr.prev = null;
if (prev !== null) {
prev.prev = curr;
}
prev = curr;
curr = next;
count++;
}
// If newHead is null, set it to the last
// node of the first group
if (newHead === null) {
newHead = prev;
}
// Connect the previous group to the
// current reversed group
if (tail !== null) {
tail.next = prev;
prev.prev = tail;
}
// Move tail to the end of the reversed group
tail = groupHead;
}
return newHead;
}
function printList(head) {
let curr = head;
while (curr !== null) {
console.log(curr.data + " ");
curr = curr.next;
}
}
// Creating a sample doubly linked list:
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6
let head = new Node(1);
head.next = new Node(2);
head.next.prev = head;
head.next.next = new Node(3);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(5);
head.next.next.next.next.prev = head.next.next.next;
head.next.next.next.next.next = new Node(6);
head.next.next.next.next.next.prev = head.next.next.next.next;
head = reverseKGroup(head, 2);
printList(head);
Time complexity: O(n), where n is the number of nodes in linked list.
Auxiliary Space: O(1)
Similar Reads
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
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 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
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 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 (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 Doubly Linked List
Given a Doubly Linked List, the task is to reverse the Doubly Linked List. Examples: Input: Doubly Linked List = 1 <-> 2 <-> 3 -> NULL Output: Reversed Doubly Linked List = 3 <-> 2 <-> 1 -> NULL Input: Doubly Linked List = 1 ->NULL Output: Reversed Doubly Linked List
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
Reverse a Doubly linked list using recursion
Given a doubly linked list. Reverse it using recursion. Original Doubly linked list Reversed Doubly linked list We have discussed Iterative solution to reverse a Doubly Linked List Algorithm: If list is empty, return Reverse head by swapping head->prev and head->next If prev = NULL it means th
9 min read
Program to find size of Doubly Linked List
Given a doubly linked list, The task is to find the size of the given doubly linked list. Example: Input : 1<->2<->3<->4output : 4Explanation: The size is 4 as there are 4 nodes in the doubly linked list. Input : 1<->2output : 2 Approach - Using While Loop – O(n) Time and O(1
7 min read