Convert Singly Linked List to XOR Linked List
Last Updated :
15 Sep, 2022
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;
};
// Utility 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 will change to curr for next iteration
prev = curr;
// curr is now pointing to next for next iteration
curr = next;
}
}
// Function to print XORed linked 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 program to Convert a Singly Linked
// List to XOR Linked List
import java.io.*;
// Linked List node
class Node
{
int data;
Node next;
// Utility 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 will change to curr for next iteration
prev = curr;
// curr is now pointing to next for next iteration
curr = next;
}
}
// Function to print XORed linked 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 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 will change to curr for next iteration
prev = curr
# curr is now pointing to next for next iteration
curr = next
# Function to print XORed linked 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
using System;
class Node
{
public int data;
public Node next;
// Utility 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 will change to curr for next iteration
prev = curr;
// curr is now pointing to next for next iteration
curr = next;
}
}
// Function to print XORed linked 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
<script>
// javascript program to Convert a Singly Linked
// List to XOR Linked List// Linked List node
class Node {
// Utility function to create new node
constructor(val) {
this.data = val;
this.next = null;
}
}
var root;
// Print singly linked list before conversion
function print( head) {
while (head != null) {
// print current node
document.write(head.data + " ");
head = head.next;
}
document.write("<br/>");
}
// Function to find XORed value of
// the node addresses
function XOR( a, b) {
return b;
}
// Function to convert singly linked
// list to XOR linked list
function convert( head) {
var curr = head;
var prev = null;
var 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 will change to curr for next iteration
prev = curr;
// curr is now pointing to next for next iteration
curr = next;
}
}
// Function to print XORed linked list
function printXOR( head) {
var curr = head;
var prev = null;
while (curr != null) {
// print current node
document.write(curr.data + " ");
var 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;
}
document.write();
}
// Driver Code
// Create following singly linked list
// 1->2->3->4
root = new Node(1);
root.next = new Node(2);
root.next.next = new Node(3);
root.next.next.next = new Node(4);
document.write("Before Conversion : <br/>");
print(root);
convert(root);
document.write("After Conversion : <br/>");
printXOR(root);
// This code contributed by gauravrajput1
</script>
OutputBefore Conversion :
1 2 3 4
After Conversion :
1 2 3 4
Complexity Analysis:
- Time complexity: O(N) where N is no of nodes in given linked list
- Auxiliary Space: O(1)
Similar Reads
Convert singly linked list into circular linked list
Given a singly linked list, the task is to convert it into a circular linked list.Examples:Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULLOutput: Explanation: Singly linked list is converted to circular by pointing last node to head.Input: head: 2 -> 4 -> 6 -> 8 -> 10 -
11 min read
Convert a String to a Singly Linked List
Given string str, the task is to convert it into a singly Linked List. Examples: Input: str = "ABCDABC" Output: A -> B -> C -> D -> A -> B -> C Input: str = "GEEKS" Output: G -> E -> E -> K -> S Approach: Create a Linked ListFetch each character of the string and insert
5 min read
Convert a Linked List to Peak list
Given a linked list, rearrange the nodes so all the even nodes are peak. Peak nodes are those nodes that have greater value than the surrounding nodes. All the nodes of the Linked List have unique values. Examples: Input: 2->4->1->9->5->3Output: 1->3->2->5->4->9Explanat
11 min read
XOR linked list- Remove first node of the linked list
Given an XOR linked list, the task is to remove the first node of the XOR linked list. Examples: Input: XLL = 4 < – > 7 < – > 9 < – > 7 Output: 7 < – > 9 < – > 7 Explanation: Removing the first node of the XOR linked list modifies XLL to 7 < – > 9 < – > 7 In
11 min read
Linked List of Linked List
Linked list of linkeÂd list, also known as nested linkeÂd lists, is a type of Linked List where each main node stores another full linked list. This structure beats old, plain linked lists. It gives way more flexibility to store and manage compleÂx data. In this article we will learn about the bas
9 min read
XOR Linked List: Remove last node of the Linked List
Given an XOR linked list, the task is to delete the node at the end of the XOR Linked List. Examples: Input: 4<–>7<–>9<–>7Output: 4<–>7<–>9Explanation: Deleting a node from the end modifies the given XOR Linked List to 4<–>7<–>9 Input: 10Output: List is empt
15+ min read
Convert a Singly Linked List to an array
Given a singly linked list and the task is to convert it into an array.Examples: Input: List = 1 -> 2 -> 3 -> 4 -> NULL Output: 1 2 3 4Input: List = 10 -> 20 -> 30 -> 40 -> 50 -> NULL Output: 10 20 30 40 50 Approach:The idea is to iterate through the linked list and for ea
5 min read
XOR Linked List - A Memory Efficient Doubly Linked List | Set 1
In this post, we're going to talk about how XOR linked lists are used to reduce the memory requirements of doubly-linked lists.We know that each node in a doubly-linked list has two pointer fields which contain the addresses of the previous and next node. On the other hand, each node of the XOR link
15+ min read
XOR Linked List – A Memory Efficient Doubly Linked List | Set 2
In the previous post, we discussed how a Doubly Linked can be created using only one space for the address field with every node. In this post, we will discuss the implementation of a memory-efficient doubly linked list. We will mainly discuss the following two simple functions. A function to insert
10 min read
XOR linked list: Reverse last K nodes of a Linked List
Given a XOR Linked List and a positive integer K, the task is to reverse the last K nodes in the given XOR linked list. Examples: Input: LL: 7 <–> 6 <–> 8 <–> 11 <–> 3 <–> 1, K = 3Output: 7<–>6<–>8<–>1<–>3<–>11 Input: LL: 7 <–> 6 <
14 min read