 GeeksforGeeks App
Open App Browser
Continue

# 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) nodes modifies the Linked List to 8 < – > 6 < – > 7 < – > 11 < – > 3.
Reversing remaining nodes of the Linked List to 8 < – > 6 < – > 7 < – > 3 < – > 11.
Therefore, the required output is 8 < – > 6 < – > 7 < – > 3 < – > 11.

Input: XLL = 7 < – > 6 < – > 8 < –> 11 < – > 3 < – > 1 < – > 2 < – > 0, K = 3
Output: 8 < – > 6 < – > 7 < – > 1 < – > 3 < – > 11 < – > 0 < – > 2

Approach: The idea is to recursively reverse every K nodes of the XOR linked list in a group and connect the first node of every group of K nodes to the last node of its previous group of nodes. The recursive function is as follows:

if (N < K) {
}
head->next = RevGInGrp(next, K, N – K)

Follow the steps below to solve the problem:

• Reverse the first K nodes of the XOR linked list and recursively reverse the remaining nodes in a group of size K. If the count of remaining nodes is less than K, then just reverse the remaining nodes.
• Finally, connect the first node of every group to the last node of its previous group.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``#include ``using` `namespace` `std;` `// Structure of a node``// in XOR linked list``struct` `Node {` `    ``// Stores data value``    ``// of a node``    ``int` `data;` `    ``// Stores XOR of previous``    ``// pointer and next pointer``    ``struct` `Node* nxp;``};` `// Function to find the XOR of address``// of two nodes``struct` `Node* XOR(``struct` `Node* a, ``struct` `Node* b)``{``    ``return` `(``struct` `Node*)((``uintptr_t``)(a) ^ (``uintptr_t``)(b));``}` `// Function to insert a node with``// given value at given position``struct` `Node* insert(``struct` `Node** head, ``int` `value)``{` `    ``// If XOR linked list is empty``    ``if` `(*head == NULL) {` `        ``// Initialize a new Node``        ``struct` `Node* node = ``new` `Node;` `        ``// Stores data value in``        ``// the node``        ``node->data = value;` `        ``// Stores XOR of previous``        ``// and next pointer``        ``node->nxp = XOR(NULL, NULL);` `        ``// Update pointer of head node``        ``*head = node;``    ``}` `    ``// If the XOR linked list``    ``// is not empty``    ``else` `{` `        ``// Stores the address``        ``// of current node``        ``struct` `Node* curr = *head;` `        ``// Stores the address``        ``// of previous node``        ``struct` `Node* prev = NULL;` `        ``// Initialize a new Node``        ``struct` `Node* node``            ``= ``new` `Node();` `        ``// Update curr node address``        ``curr->nxp = XOR(node, XOR(NULL, curr->nxp));` `        ``// Update new node address``        ``node->nxp = XOR(NULL, curr);` `        ``// Update head``        ``*head = node;` `        ``// Update data value of``        ``// current node``        ``node->data = value;``    ``}``    ``return` `*head;``}` `// Function to print elements of``// the XOR Linked List``void` `printList(``struct` `Node** head)``{` `    ``// Stores XOR pointer``    ``// in current node``    ``struct` `Node* curr = *head;` `    ``// Stores XOR pointer of``    ``// in previous Node``    ``struct` `Node* prev = NULL;` `    ``// Stores XOR pointer of``    ``// in next node``    ``struct` `Node* next;` `    ``// Traverse XOR linked list``    ``while` `(curr != NULL) {` `        ``// Print current node``        ``cout << curr->data << ``" "``;` `        ``// Forward traversal``        ``next = XOR(prev, curr->nxp);` `        ``// Update prev``        ``prev = curr;` `        ``// Update curr``        ``curr = next;``    ``}``}` `// Reverse the linked list in group of K``struct` `Node* RevInGrp(``struct` `Node** head, ``int` `K, ``int` `len)``{` `    ``// Stores head node``    ``struct` `Node* curr = *head;` `    ``// If the XOR linked``    ``// list is empty``    ``if` `(curr == NULL)``        ``return` `NULL;` `    ``// Stores count of nodes``    ``// reversed in current group``    ``int` `count = 0;` `    ``// Stores XOR pointer of``    ``// in previous Node``    ``struct` `Node* prev = NULL;` `    ``// Stores XOR pointer of``    ``// in next node``    ``struct` `Node* next;` `    ``// Reverse nodes in current group``    ``while` `(count < K && count < len) {` `        ``// Forward traversal``        ``next = XOR(prev, curr->nxp);` `        ``// Update prev``        ``prev = curr;` `        ``// Update curr``        ``curr = next;` `        ``// Update count``        ``count++;``    ``}` `    ``// Disconnect prev node from the next node``    ``prev->nxp = XOR(NULL, XOR(prev->nxp, curr));` `    ``// Disconnect curr from previous node``    ``if` `(curr != NULL)``        ``curr->nxp = XOR(XOR(curr->nxp, prev), NULL);` `    ``// If the count of remaining``    ``// nodes is less than K``    ``if` `(len < K) {``        ``return` `prev;``    ``}``    ``else` `{` `        ``// Update len``        ``len -= K;` `        ``// Recursively process the next nodes``        ``struct` `Node* dummy = RevInGrp(&curr, K, len);` `        ``// Connect the head pointer with the prev``        ``(*head)->nxp = XOR(XOR(NULL, (*head)->nxp), dummy);` `        ``// Connect prev with the head``        ``if` `(dummy != NULL)``            ``dummy->nxp = XOR(XOR(dummy->nxp, NULL), *head);``        ``return` `prev;``    ``}``}` `// Driver Code``int` `main()``{` `    ``/* Create following XOR Linked List``    ``head-->7<–>6<–>8<–>11<–>3<–>1<–>2<–>0*/``    ``struct` `Node* head = NULL;``    ``insert(&head, 0);``    ``insert(&head, 2);``    ``insert(&head, 1);``    ``insert(&head, 3);``    ``insert(&head, 11);``    ``insert(&head, 8);``    ``insert(&head, 6);``    ``insert(&head, 7);` `    ``// Function Call``    ``head = RevInGrp(&head, 3, 8);` `    ``// Print the reversed list``    ``printList(&head);` `    ``return` `(0);``}` `// This code is contributed by pankajsharmagfg.`

## C

 `// C program to implement``// the above approach` `#include ``#include ``#include ` `// Structure of a node``// in XOR linked list``struct` `Node {` `    ``// Stores data value``    ``// of a node``    ``int` `data;` `    ``// Stores XOR of previous``    ``// pointer and next pointer``    ``struct` `Node* nxp;``};` `// Function to find the XOR of address``// of two nodes``struct` `Node* XOR(``struct` `Node* a,``                 ``struct` `Node* b)``{``    ``return` `(``struct` `Node*)((``uintptr_t``)(a)``                          ``^ (``uintptr_t``)(b));``}` `// Function to insert a node with``// given value at given position``struct` `Node* insert(``struct` `Node** head,``                    ``int` `value)``{` `    ``// If XOR linked list is empty``    ``if` `(*head == NULL) {` `        ``// Initialize a new Node``        ``struct` `Node* node``            ``= (``struct` `Node*)``malloc``(``                ``sizeof``(``struct` `Node));` `        ``// Stores data value in``        ``// the node``        ``node->data = value;` `        ``// Stores XOR of previous``        ``// and next pointer``        ``node->nxp = XOR(NULL, NULL);` `        ``// Update pointer of head node``        ``*head = node;``    ``}` `    ``// If the XOR linked list``    ``// is not empty``    ``else` `{` `        ``// Stores the address``        ``// of current node``        ``struct` `Node* curr = *head;` `        ``// Stores the address``        ``// of previous node``        ``struct` `Node* prev = NULL;` `        ``// Initialize a new Node``        ``struct` `Node* node``            ``= (``struct` `Node*)``malloc``(``                ``sizeof``(``struct` `Node));` `        ``// Update curr node address``        ``curr->nxp = XOR(node, XOR(NULL,``                                  ``curr->nxp));` `        ``// Update new node address``        ``node->nxp = XOR(NULL, curr);` `        ``// Update head``        ``*head = node;` `        ``// Update data value of``        ``// current node``        ``node->data = value;``    ``}``    ``return` `*head;``}` `// Function to print elements of``// the XOR Linked List``void` `printList(``struct` `Node** head)``{` `    ``// Stores XOR pointer``    ``// in current node``    ``struct` `Node* curr = *head;` `    ``// Stores XOR pointer of``    ``// in previous Node``    ``struct` `Node* prev = NULL;` `    ``// Stores XOR pointer of``    ``// in next node``    ``struct` `Node* next;` `    ``// Traverse XOR linked list``    ``while` `(curr != NULL) {` `        ``// Print current node``        ``printf``(``"%d "``, curr->data);` `        ``// Forward traversal``        ``next = XOR(prev, curr->nxp);` `        ``// Update prev``        ``prev = curr;` `        ``// Update curr``        ``curr = next;``    ``}``}` `// Reverse the linked list in group of K``struct` `Node* RevInGrp(``struct` `Node** head,``                      ``int` `K, ``int` `len)``{` `    ``// Stores head node``    ``struct` `Node* curr = *head;` `    ``// If the XOR linked``    ``// list is empty``    ``if` `(curr == NULL)``        ``return` `NULL;` `    ``// Stores count of nodes``    ``// reversed in current group``    ``int` `count = 0;` `    ``// Stores XOR pointer of``    ``// in previous Node``    ``struct` `Node* prev = NULL;` `    ``// Stores XOR pointer of``    ``// in next node``    ``struct` `Node* next;` `    ``// Reverse nodes in current group``    ``while` `(count < K && count < len) {` `        ``// Forward traversal``        ``next = XOR(prev, curr->nxp);` `        ``// Update prev``        ``prev = curr;` `        ``// Update curr``        ``curr = next;` `        ``// Update count``        ``count++;``    ``}` `    ``// Disconnect prev node from the next node``    ``prev->nxp = XOR(NULL, XOR(prev->nxp, curr));` `    ``// Disconnect curr from previous node``    ``if` `(curr != NULL)``        ``curr->nxp = XOR(XOR(curr->nxp, prev), NULL);` `    ``// If the count of remaining``    ``// nodes is less than K``    ``if` `(len < K) {``        ``return` `prev;``    ``}``    ``else` `{` `        ``// Update len``        ``len -= K;` `        ``// Recursively process the next nodes``        ``struct` `Node* dummy``            ``= RevInGrp(&curr, K, len);` `        ``// Connect the head pointer with the prev``        ``(*head)->nxp = XOR(XOR(NULL,``                               ``(*head)->nxp),``                           ``dummy);` `        ``// Connect prev with the head``        ``if` `(dummy != NULL)``            ``dummy->nxp = XOR(XOR(dummy->nxp, NULL),``                             ``*head);``        ``return` `prev;``    ``}``}` `// Driver Code``int` `main()``{` `    ``/* Create following XOR Linked List``    ``head-->7<–>6<–>8<–>11<–>3<–>1<–>2<–>0*/``    ``struct` `Node* head = NULL;``    ``insert(&head, 0);``    ``insert(&head, 2);``    ``insert(&head, 1);``    ``insert(&head, 3);``    ``insert(&head, 11);``    ``insert(&head, 8);``    ``insert(&head, 6);``    ``insert(&head, 7);` `    ``// Function Call``    ``head = RevInGrp(&head, 3, 8);` `    ``// Print the reversed list``    ``printList(&head);` `    ``return` `(0);``}`

Output:

`8 6 7 1 3 11 0 2`

Time Complexity: O(N)
Auxiliary Space: O(N / K)

My Personal Notes arrow_drop_up