Skip to content
Related Articles

Related Articles

Convert Singly Linked List to XOR Linked List
  • Difficulty Level : Basic
  • Last Updated : 29 Jan, 2021
GeeksforGeeks - Summer Carnival Banner

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.
 

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)

Printing the XOR linked list
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 <bits/stdc++.h>
 
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;
 
        // cahnge 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;
             
            // cahnge 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
 
        # cahnge 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;
              
            // cahnge 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
Output: 
Before Conversion : 
1 2 3 4 
After Conversion : 
1 2 3 4

 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :