• Difficulty Level : Basic
• Last Updated : 29 Oct, 2021

Prerequisite

An XOR linked list is a memory efficient doubly linked list in which the next pointer of every node stores the XOR of previous and next node’s address.
Given a singly linked list, the task is to convert the given singly list to a XOR linked list.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach: Since in XOR linked list each next pointer stores the XOR of prev and next nodes’s address. So the idea is to traverse the given singly linked list and keep track of the previous node in a pointer say prev.
Now, while traversing the list, change the next pointer of every node as:

`current -> next = XOR(prev, current->next)`

While printing XOR linked list we have to find the exact address of the next node every time. As we have seen above that the next pointer of every node stores the XOR value of prev and next node’s address. Therefore, the next node’s address can be obtained by finding XOR of prev and next pointer of current node in the XOR linked list.
So, to print the XOR linked list, traverse it by maintaining a prev pointer which stores the address of the previous node and to find the next node, calculate XOR of prev with next of current node.
Below is the implementation of the above approach:

## CPP

 `// C++ program to Convert a Singly Linked``// List to XOR Linked List` `#include ` `using` `namespace` `std;` `// Linked List node``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Utiltity function to create new node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->next = NULL;` `    ``return` `temp;``}` `// Print singly linked list before conversion``void` `print(Node* head)``{``    ``while` `(head) {` `        ``// print current node``        ``cout << head->data << ``" "``;``        ``head = head->next;``    ``}` `    ``cout << endl;``}` `// Function to find XORed value of``// the node addresses``Node* XOR(Node* a, Node* b)``{``    ``return` `(Node*)((``uintptr_t``)(a) ^ (``uintptr_t``)(b));``}` `// Function to convert singly linked``// list to XOR linked list``void` `convert(Node* head)``{``    ``Node* curr = head;``    ``Node* prev = NULL;``    ``Node* next = curr->next;` `    ``while` `(curr) {` `        ``// store curr->next in next``        ``next = curr->next;` `        ``// change curr->next to XOR of prev and next``        ``curr->next = XOR(prev, next);` `        ``// prev wil change to curr for next iteration``        ``prev = curr;` `        ``// curr is now pointing to next for next iteration``        ``curr = next;``    ``}``}` `// Function to print XORed liked list``void` `printXOR(Node* head)``{``    ``Node* curr = head;``    ``Node* prev = NULL;` `    ``while` `(curr) {` `        ``// print current node``        ``cout << curr->data << ``" "``;` `        ``Node* temp = curr;` `        ``/* compute curr as prev^curr->next as``           ``it is previously set as prev^curr->next so``           ``this time curr would be prev^prev^curr->next``           ``which is curr->next */``        ``curr = XOR(prev, curr->next);` `        ``prev = temp;``    ``}` `    ``cout << endl;``}` `// Driver Code``int` `main()``{``    ``// Create following singly linked list``    ``// 1->2->3->4``    ``Node* head = newNode(1);``    ``head->next = newNode(2);``    ``head->next->next = newNode(3);``    ``head->next->next->next = newNode(4);` `    ``cout << ``"Before Conversion : "` `<< endl;``    ``print(head);` `    ``convert(head);``    ``cout << ``"After Conversion : "` `<< endl;``    ``printXOR(head);` `    ``return` `0;``}`

## Java

 `// Java program to Convert a Singly Linked``// List to XOR Linked List``import` `java.io.*;` `// Linked List node``class` `Node``{``    ``int` `data;``    ``Node next;``   ` `    ``// Utiltity function to create new node``    ``Node(``int` `item)``    ``{``        ``data = item;``        ``next = ``null``;``    ``}``}``class` `GFG``{``    ``public` `static` `Node root;``  ` `    ``// Print singly linked list before conversion``    ``static` `void` `print(Node head)``    ``{``        ``while` `(head != ``null``)``        ``{``          ` `            ``// print current node``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println();``    ``}``  ` `    ``// Function to find XORed value of``    ``// the node addresses``    ``static` `Node XOR(Node a, Node b)``    ``{``        ``return` `b;``    ``}``  ` `    ``// Function to convert singly linked``    ``// list to XOR linked list``    ``static` `void` `convert(Node head)``    ``{``        ``Node curr = head;``        ``Node prev = ``null``;``        ``Node next = curr.next;``        ` `        ``while``(curr != ``null``)``        ``{``          ` `            ``// store curr->next in next``            ``next = curr.next;``            ` `            ``// change curr->next to XOR of prev and next``            ``curr.next = XOR(prev, next);``            ` `            ``// prev wil change to curr for next iteration``            ``prev = curr;``            ` `            ``// curr is now pointing to next for next iteration``            ``curr = next;``        ``}``    ``}``  ` `    ``// Function to print XORed liked list``    ``static` `void` `printXOR(Node head)``    ``{``        ``Node curr = head;``        ``Node prev = ``null``;``        ``while``(curr != ``null``)``        ``{``          ` `            ``// print current node``            ``System.out.print(curr.data + ``" "``);``            ``Node temp = curr;``            ` `            ``/* compute curr as prev^curr->next as``           ``it is previously set as prev^curr->next so``           ``this time curr would be prev^prev^curr->next``           ``which is curr->next */``            ``curr = XOR(prev, curr.next);``            ``prev = temp;``        ``}``        ``System.out.println();``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args)``    ``{``      ` `        ``// Create following singly linked list``        ``// 1->2->3->4``        ``GFG tree = ``new` `GFG();``        ``tree.root = ``new` `Node(``1``);``        ``tree.root.next = ``new` `Node(``2``);``        ``tree.root.next.next = ``new` `Node(``3``);``        ``tree.root.next.next.next = ``new` `Node(``4``);     ``        ``System.out.println(``"Before Conversion : "``);``        ``print(root);``        ``convert(root);``        ``System.out.println(``"After Conversion : "``);``        ``printXOR(root);``    ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program to Convert a Singly Linked``# List to XOR Linked List` `# Linked List node``class` `Node:``    ``def` `__init__(``self``,d):``        ``self``.data ``=` `d``        ``self``.``next` `=` `None` `# Print singly linked list before conversion``def` `printt(head):``    ``while` `(head):` `        ``# print current node``        ``print``(head.data, end``=``" "``)``        ``head ``=` `head.``next``    ``print``()` `# Function to find XORed value of``# the node addresses``def` `XOR(a, b):``    ``return` `b` `# Function to convert singly linked``# list to XOR linked list``def` `convert(head):``    ``curr ``=` `head``    ``prev ``=` `None``    ``next` `=` `curr.``next` `    ``while` `(curr):` `        ``# store curr.next in next``        ``next` `=` `curr.``next` `        ``# change curr.next to XOR of prev and next``        ``curr.``next` `=` `XOR(prev, ``next``)` `        ``# prev wil change to curr for next iteration``        ``prev ``=` `curr` `        ``# curr is now pointing to next for next iteration``        ``curr ``=` `next` `# Function to print XORed liked list``def` `printXOR(head):``    ``curr ``=` `head``    ``prev ``=` `None` `    ``while` `(curr):` `        ``# print current node``        ``print``(curr.data, end``=``" "``)` `        ``temp ``=` `curr` `        ``# /* compute curr as prev^curr.next as``        ``#    it is previously set as prev^curr.next so``        ``#    this time curr would be prev^prev^curr.next``        ``#    which is curr.next */``        ``curr ``=` `XOR(prev, curr.``next``)` `        ``prev ``=` `temp` `    ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Create following singly linked list``    ``# 1.2.3.4``    ``head ``=` `Node(``1``)``    ``head.``next` `=` `Node(``2``)``    ``head.``next``.``next` `=` `Node(``3``)``    ``head.``next``.``next``.``next` `=` `Node(``4``)` `    ``print``(``"Before Conversion : "``)``    ``printt(head)` `    ``convert(head)``    ``print``(``"After Conversion : "``)``    ``printXOR(head)` `# This code is contributed by mohitkumar29`

## C#

 `using` `System;``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``    ` `    ``// Utiltity function to create new node``    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``next = ``null``;``    ``}``}` `public` `class` `GFG``{``    ``static` `Node root;``  ` `    ``// Print singly linked list before conversion``    ``static` `void` `print(Node head)``    ``{``        ``while` `(head != ``null``)``        ``{``           ` `            ``// print current node``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine();``    ``}``  ` `    ``// Function to find XORed value of``    ``// the node addresses``    ``static` `Node XOR(Node a, Node b)``    ``{``        ``return` `b;``    ``}``    ` `    ``// Function to convert singly linked``    ``// list to XOR linked list``    ``static` `void` `convert(Node head)``    ``{``        ``Node curr = head;``        ``Node prev = ``null``;``        ``Node next = curr.next;       ``        ``while``(curr != ``null``)``        ``{``           ` `            ``// store curr->next in next``            ``next = curr.next;``             ` `            ``// change curr->next to XOR of prev and next``            ``curr.next = XOR(prev, next);``             ` `            ``// prev wil change to curr for next iteration``            ``prev = curr;``             ` `            ``// curr is now pointing to next for next iteration``            ``curr = next;``        ``}``    ``}``    ` `    ``// Function to print XORed liked list``    ``static` `void` `printXOR(Node head)``    ``{``        ``Node curr = head;``        ``Node prev = ``null``;``        ``while``(curr != ``null``)``        ``{``           ` `            ``// print current node``            ``Console.Write(curr.data + ``" "``);``            ``Node temp = curr;``             ` `            ``/* compute curr as prev^curr->next as``           ``it is previously set as prev^curr->next so``           ``this time curr would be prev^prev^curr->next``           ``which is curr->next */``            ``curr = XOR(prev, curr.next);``            ``prev = temp;``        ``}``        ``Console.WriteLine();``    ``}``    ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``      ` `        ``// Create following singly linked list``        ``// 1->2->3->4``        ``GFG.root = ``new` `Node(1);``        ``GFG.root.next = ``new` `Node(2);``        ``GFG.root.next.next = ``new` `Node(3);``        ``GFG.root.next.next.next = ``new` `Node(4);     ``        ` `        ``Console.WriteLine(``"Before Conversion : "``);``        ``print(root);``        ``convert(root);``        ``Console.WriteLine(``"After Conversion : "``);``        ``printXOR(root);``    ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``
Output:
```Before Conversion :
1 2 3 4
After Conversion :
1 2 3 4```

My Personal Notes arrow_drop_up