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 <-> 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.

👁 Reverse-a-doubly-linked-list-in-groups-of-K-size-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.

👁 Reverse-a-doubly-linked-list-in-groups-of-K-size-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.

2 1 4 3 6 5 

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: 

2 1 4 3 6 5 

Time complexity: O(n), where n is the number of nodes in linked list.
Auxiliary Space: O(1)