# XOR Linked List – Reverse a Linked List in groups of given size

Last Updated : 18 Jan, 2024

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);` `}`

## Java

 `// Java program to reverse a linked list in groups of ` `// given size ` `class` `LinkedList { ` `    ``Node head; ``// head of list `   `    ``/* Linked list Node*/` `    ``class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `        ``Node(``int` `d) ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} `   `    ``Node reverse(Node head, ``int` `k) ` `    ``{ ` `        ``if``(head == ``null``) ` `        ``return` `null``; ` `        ``Node current = head; ` `        ``Node next = ``null``; ` `        ``Node prev = ``null``; `   `        ``int` `count = ``0``; `   `        ``/* Reverse first k nodes of linked list */` `        ``while` `(count < k && current != ``null``) { ` `            ``next = current.next; ` `            ``current.next = prev; ` `            ``prev = current; ` `            ``current = next; ` `            ``count++; ` `        ``} `   `        ``/* next is now a pointer to (k+1)th node ` `        ``Recursively call for the list starting from ` `        ``current. And make rest of the list as next of ` `        ``first node */` `        ``if` `(next != ``null``) ` `            ``head.next = reverse(next, k); `   `        ``// prev is now head of input list ` `        ``return` `prev; ` `    ``} `   `    ``/* Utility functions */`   `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data) ` `    ``{ ` `        ``/* 1 & 2: Allocate the Node & ` `                ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data); `   `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head; `   `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node; ` `    ``} `   `    ``/* Function to print linked list */` `    ``void` `printList() ` `    ``{ ` `        ``Node temp = head; ` `        ``while` `(temp != ``null``) { ` `            ``System.out.print(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `        ``System.out.println(); ` `    ``} `   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); `   `        ``/* Constructed Linked List is 1->2->3->4->5->6-> ` `        ``7->8->8->9->null */` `        ``llist.push(``0``); ` `        ``llist.push(``2``); ` `        ``llist.push(``1``); ` `        ``llist.push(``3``); ` `        ``llist.push(``11``); ` `        ``llist.push(``8``); ` `        ``llist.push(``6``); ` `        ``llist.push(``7``);` `        ``llist.head = llist.reverse(llist.head, ``3``); ` `        ``llist.printList(); ` `    ``} ` `} ` `/* This code is contributed by Rajat Mishra */`

## Python3

 `class` `LinkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None`   `    ``class` `Node:` `        ``def` `__init__(``self``, data):` `            ``self``.data ``=` `data` `            ``self``.``next` `=` `None`   `    ``def` `reverse(``self``, head, k):` `        ``if` `head ``is` `None``:` `            ``return` `None` `        ``current ``=` `head` `        ``next_node ``=` `None` `        ``prev ``=` `None` `        ``count ``=` `0`   `        ``while` `count < k ``and` `current ``is` `not` `None``:` `            ``next_node ``=` `current.``next` `            ``current.``next` `=` `prev` `            ``prev ``=` `current` `            ``current ``=` `next_node` `            ``count ``+``=` `1`   `        ``if` `next_node ``is` `not` `None``:` `            ``head.``next` `=` `self``.reverse(next_node, k)`   `        ``return` `prev`   `    ``def` `push(``self``, new_data):` `        ``new_node ``=` `self``.Node(new_data)` `        ``new_node.``next` `=` `self``.head` `        ``self``.head ``=` `new_node`   `    ``def` `print_list(``self``):` `        ``temp ``=` `self``.head` `        ``while` `temp ``is` `not` `None``:` `            ``print``(temp.data, end``=``" "``)` `            ``temp ``=` `temp.``next` `        ``print``()`   `# Driver program to test above functions` `if` `__name__ ``=``=` `"__main__"``:` `    ``llist ``=` `LinkedList()`   `    ``# Constructed Linked List is 1->2->3->4->5->6->7->8->8->9->None` `    ``llist.push(``0``)` `    ``llist.push(``2``)` `    ``llist.push(``1``)` `    ``llist.push(``3``)` `    ``llist.push(``11``)` `    ``llist.push(``8``)` `    ``llist.push(``6``)` `    ``llist.push(``7``)` `    ``llist.head ``=` `llist.reverse(llist.head, ``3``)` `    ``llist.print_list()` `#This code is contributed Dibyabrata Panja`

## C#

 `using` `System;`   `public` `class` `LinkedList` `{` `    ``public` `Node head;`   `    ``// Node class to represent each element in the linked list` `    ``public` `class` `Node` `    ``{` `        ``public` `int` `data;` `        ``public` `Node next;`   `        ``public` `Node(``int` `data)` `        ``{` `            ``this``.data = data;` `            ``this``.next = ``null``;` `        ``}` `    ``}`   `    ``// Function to reverse the linked list in groups of k` `    ``public` `Node Reverse(Node head, ``int` `k)` `    ``{` `        ``if` `(head == ``null``)` `            ``return` `null``;`   `        ``Node current = head;` `        ``Node nextNode = ``null``;` `        ``Node prev = ``null``;` `        ``int` `count = 0;`   `        ``// Reverse k nodes` `        ``while` `(count < k && current != ``null``)` `        ``{` `            ``nextNode = current.next;` `            ``current.next = prev;` `            ``prev = current;` `            ``current = nextNode;` `            ``count++;` `        ``}`   `        ``// Recursive call for the remaining nodes` `        ``if` `(nextNode != ``null``)` `            ``head.next = Reverse(nextNode, k);`   `        ``return` `prev;` `    ``}`   `    ``// Function to push a new element to the linked list` `    ``public` `void` `Push(``int` `newData)` `    ``{` `        ``Node newNode = ``new` `Node(newData);` `        ``newNode.next = head;` `        ``head = newNode;` `    ``}`   `    ``// Function to print the linked list` `    ``public` `void` `PrintList()` `    ``{` `        ``Node temp = head;` `        ``while` `(temp != ``null``)` `        ``{` `            ``Console.Write(temp.data + ``" "``);` `            ``temp = temp.next;` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``// Driver program to test the functions` `    ``public` `static` `void` `Main()` `    ``{` `        ``LinkedList llist = ``new` `LinkedList();`   `        ``// Constructed Linked List is 1->2->3->4->5->6->7->8->8->9->None` `        ``llist.Push(0);` `        ``llist.Push(2);` `        ``llist.Push(1);` `        ``llist.Push(3);` `        ``llist.Push(11);` `        ``llist.Push(8);` `        ``llist.Push(6);` `        ``llist.Push(7);` `        ``llist.head = llist.Reverse(llist.head, 3);` `        ``llist.PrintList();` `    ``}` `}`

## Javascript

 `// Node class to represent linked list nodes` `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `// LinkedList class` `class LinkedList {` `    ``constructor() {` `        ``this``.head = ``null``;` `    ``}`   `    ``// Function to reverse the linked list in groups of given size` `    ``reverse(head, k) {` `        ``if` `(head === ``null``)` `            ``return` `null``;`   `        ``let current = head;` `        ``let next = ``null``;` `        ``let prev = ``null``;` `        ``let count = 0;`   `        ``// Reverse first k nodes of linked list` `        ``while` `(count < k && current !== ``null``) {` `            ``next = current.next;` `            ``current.next = prev;` `            ``prev = current;` `            ``current = next;` `            ``count++;` `        ``}`   `        ``// Recursively call for the list starting from current` `        ``// And make rest of the list as the next of the first node` `        ``if` `(next !== ``null``)` `            ``head.next = ``this``.reverse(next, k);`   `        ``// prev is now the head of the input list` `        ``return` `prev;` `    ``}`   `    ``// Utility function to insert a new Node at the front of the list` `    ``push(newData) {` `        ``const newNode = ``new` `Node(newData);` `        ``newNode.next = ``this``.head;` `        ``this``.head = newNode;` `    ``}`   `    ``// Function to print linked list` `    ``printList() {` `        ``let temp = ``this``.head;` `        ``while` `(temp !== ``null``) {` `            ``console.log(temp.data + ``" "``);` `            ``temp = temp.next;` `        ``}` `        ``console.log();` `    ``}` `}`   `// Driver program` `const llist = ``new` `LinkedList();`   `// Constructed Linked List: 1->2->3->4->5->6->7->8->9->null` `llist.push(0);` `llist.push(2);` `llist.push(1);` `llist.push(3);` `llist.push(11);` `llist.push(8);` `llist.push(6);` `llist.push(7);`   `// Reverse the linked list in groups of 3` `llist.head = llist.reverse(llist.head, 3);`   `// Print the reversed linked list` `llist.printList();`

Output

`8 6 7 1 3 11 0 2 `

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

Previous
Next