XOR Linked List - Reversal of a List
Last Updated :
25 Nov, 2023
Given a XOR linked list, the task is to reverse the XOR linked list.
Examples:
Input: 4 <–> 7 <–> 9 <–> 7
Output: 7 <–> 9 <–> 7 <–> 4
Explanation:
Reversing the linked list modifies the XOR linked list to 7 <–> 9 <–> 7 <–> 4.
Input: 2 <-> 5 <-> 7 <-> 4
Output: 4 <-> 7 <-> 5 <-> 2
Explanation:
Reversing the linked list modifies the XOR linked list to 4 <-> 7 <-> 5 <-> 2.
Approach: XOR linked listconsists of a single pointer, which is the only pointer needed to traverse the XOR linked list in both directions. Therefore, the idea to solve this problem is only by making the last node of the XOR linked list its Head Node. Follow the steps below to solve the problem:
- Initialize a pointer variable, say curr, to pointto the current node being traversed.
- Store the current head pointer in the curr variable.
- If curr is equal to NULL, then return NULL.
- Otherwise, traverse upto the last node and make it the head of the XOR linked list.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include<bits/stdc++.h>
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
Node* nxp;
};
// Function to find the XOR of two nodes
Node* XOR(Node* a, Node* b)
{
return (Node*)((uintptr_t)(a) ^ (uintptr_t)(b));
}
// Function to insert a node with
// given value at beginning position
Node* insert(Node** head, int value)
{
// If XOR linked list is empty
if (*head == NULL)
{
// Initialize a new Node
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
Node* curr = *head;
// Stores the address
// of previous node
Node* prev = NULL;
// Initialize a new Node
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(Node** head)
{
// Stores XOR pointer
// in current node
Node* curr = *head;
// Stores XOR pointer of
// in previous Node
Node* prev = NULL;
// Stores XOR pointer of
// in next node
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;
}
cout << endl;
}
// Function to reverse the XOR linked list
Node* reverse(Node** head)
{
// Stores XOR pointer
// in current node
Node* curr = *head;
if (curr == NULL)
return NULL;
else
{
// Stores XOR pointer of
// in previous Node
Node* prev = NULL;
// Stores XOR pointer of
// in next node
Node* next;
while (XOR(prev, curr->nxp) != NULL)
{
// Forward traversal
next = XOR(prev, curr->nxp);
// Update prev
prev = curr;
// Update curr
curr = next;
}
// Update the head pointer
*head = curr;
return *head;
}
}
// Driver Code
int main()
{
/* Create following XOR Linked List
head-->40<-->30<-->20<-->10 */
Node* head = NULL;
insert(&head, 10);
insert(&head, 20);
insert(&head, 30);
insert(&head, 40);
/* Reverse the XOR Linked List to give
head-->10<-->20<-->30<-->40 */
cout << "XOR linked list: ";
printList(&head);
reverse(&head);
cout << "Reversed XOR linked list: ";
printList(&head);
return 0;
}
// This code is contributed by rutvik_56.
// C program for the above approach
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
// 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 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 beginning 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;
}
printf("\n");
}
// Function to reverse the XOR linked list
struct Node* reverse(struct Node** head)
{
// Stores XOR pointer
// in current node
struct Node* curr = *head;
if (curr == NULL)
return NULL;
else {
// Stores XOR pointer of
// in previous Node
struct Node* prev = NULL;
// Stores XOR pointer of
// in next node
struct Node* next;
while (XOR(prev, curr->nxp) != NULL) {
// Forward traversal
next = XOR(prev, curr->nxp);
// Update prev
prev = curr;
// Update curr
curr = next;
}
// Update the head pointer
*head = curr;
return *head;
}
}
// Driver Code
int main()
{
/* Create following XOR Linked List
head-->40<-->30<-->20<-->10 */
struct Node* head = NULL;
insert(&head, 10);
insert(&head, 20);
insert(&head, 30);
insert(&head, 40);
/* Reverse the XOR Linked List to give
head-->10<-->20<-->30<-->40 */
printf("XOR linked list: ");
printList(&head);
reverse(&head);
printf("Reversed XOR linked list: ");
printList(&head);
return (0);
}
import java.util.ArrayList;
import java.util.List;
// Structure of a node in XOR linked list
class Node {
int value;
int npx;
public Node(int value) {
this.value = value;
this.npx = 0;
}
}
// Create XOR Linked List class
class XorLinkedList {
private Node head;
private Node tail;
private List<Node> nodes = new ArrayList<>();
// Function to insert a node with given value at the beginning
public void insert(int value) {
Node node = new Node(value);
nodes.add(node);
if (head == null) {
head = node;
tail = node;
} else {
head.npx = System.identityHashCode(node) ^ head.npx;
node.npx = System.identityHashCode(head);
head = node;
}
}
// Function to print elements of the XOR Linked List
public void printList() {
if (head != null) {
int prevId = 0;
Node node = head;
int nextId = 1;
System.out.print(node.value + " ");
while (nextId != 0) {
nextId = prevId ^ node.npx;
if (nextId != 0) {
prevId = System.identityHashCode(node);
node = getTypeCast(nextId);
System.out.print(node.value + " ");
} else {
return;
}
}
}
}
// Method to check if the linked list is empty or not
public boolean isEmpty() {
return head == null;
}
// Method to return a new instance of type
private Node getTypeCast(int id) {
for (Node node : nodes) {
if (System.identityHashCode(node) == id) {
return node;
}
}
return null;
}
// Function to reverse the XOR linked list
public void reverse() {
if (head != null) {
int prevId = 0;
Node node = tail;
int nextId = 1;
System.out.print(node.value + " ");
while (nextId != 0) {
nextId = prevId ^ node.npx;
if (nextId != 0) {
prevId = System.identityHashCode(node);
node = getTypeCast(nextId);
System.out.print(node.value + " ");
} else {
return;
}
}
}
}
}
public class Main {
public static void main(String[] args) {
// Create following XOR Linked List
// head-->40<-->30<-->20<-->10
XorLinkedList head = new XorLinkedList();
head.insert(10);
head.insert(20);
head.insert(30);
head.insert(40);
// Reverse the XOR Linked List to give
// head-->10<-->20<-->30<-->40
System.out.print("XOR linked list: ");
head.printList();
System.out.println();
System.out.print("Reversed XOR linked list: ");
head.reverse();
}
}
# Python program for the above approach
import ctypes
# Structure of a node in XOR linked list
class Node:
def __init__(self, value):
self.value = value
self.npx = 0
# create linked list class
class XorLinkedList:
# constructor
def __init__(self):
self.head = None
self.tail = None
self.__nodes = []
# Function to insert a node with given value at given position
def insert(self, value):
# Initialize a new Node
node = Node(value)
# Check If XOR linked list is empty
if self.head is None:
# Update pointer of head node
self.head = node
# Update pointer of tail node
self.tail = node
else:
# Update curr node address
self.head.npx = id(node) ^ self.head.npx
# Update new node address
node.npx = id(self.head)
# Update head
self.head = node
# push node
self.__nodes.append(node)
# Function to print elements of the XOR Linked List
def printList(self):
if self.head != None:
prev_id = 0
node = self.head
next_id = 1
print(node.value, end=' ')
# Traverse XOR linked list
while next_id:
# Forward traversal
next_id = prev_id ^ node.npx
if next_id:
# Update prev
prev_id = id(node)
# Update curr
node = self.__type_cast(next_id)
# Print current node
print(node.value, end=' ')
else:
return
# method to check if the linked list is empty or not
def isEmpty(self):
if self.head is None:
return True
return False
# method to return a new instance of type
def __type_cast(self, id):
return ctypes.cast(id, ctypes.py_object).value
# Function to reverse the XOR linked list
def reverse(self):
# Print Values is reverse order.
if self.head != None:
# Stores XOR pointer of
# in previous Node
prev_id = 0
node = self.tail
# Stores XOR pointer of
# in next node
next_id = 1
print(node.value, end=' ')
while next_id:
# Forward traversal
next_id = prev_id ^ node.npx
if next_id:
# Update prev
prev_id = id(node)
# Update curr
node = self.__type_cast(next_id)
print(node.value, end=' ')
else:
return
# Create following XOR Linked List
# head-->40<-->30<-->20<-->10
head = XorLinkedList()
head.insert(10)
head.insert(20)
head.insert(30)
head.insert(40)
# Reverse the XOR Linked List to give
# head-->10<-->20<-->30<-->40
print("XOR linked list: ", end = "")
head.printList()
print()
print("Reversed XOR linked list: ", end = "")
head.reverse()
# This code is contributed by Nidhi goel.
using System;
public class Node
{
public int data;
public Node next;
public Node prev;
public Node(int value)
{
data = value;
next = null;
prev = null;
}
}
public class XORLinkedList
{
// Function to insert a node with given value at the beginning position
public static Node Insert(Node head, int value)
{
Node node = new Node(value);
if (head == null)
{
head = node;
}
else
{
node.next = head;
head.prev = node;
head = node;
}
return head;
}
// Function to print elements of the linked list
public static void PrintList(Node head)
{
Node curr = head;
while (curr != null)
{
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
// Function to reverse the linked list
public static Node Reverse(Node head)
{
Node curr = head;
Node prev = null;
while (curr != null)
{
Node next = curr.next;
curr.next = prev;
curr.prev = next;
prev = curr;
curr = next;
}
return prev;
}
// Driver Code
public static void Main(string[] args)
{
/* Create a linked list: head --> 40 --> 30 --> 20 --> 10 */
Node head = null;
head = Insert(head, 10);
head = Insert(head, 20);
head = Insert(head, 30);
head = Insert(head, 40);
/* Reverse the linked list to give head --> 10 --> 20 --> 30 --> 40 */
Console.Write("Linked list: ");
PrintList(head);
head = Reverse(head);
Console.Write("Reversed linked list: ");
PrintList(head);
}
}
// Definition of a node in XOR linked list
class Node {
constructor(data) {
this.data = data;
this.nxp = null; // XOR of previous and next pointer
}
}
// Function to find the XOR of two nodes
function XOR(a, b) {
return a ^ b; // Assuming XOR (^) is bitwise XOR in JavaScript
}
// Function to insert a node with given value at the beginning position
function insert(head, value) {
// If XOR linked list is empty
if (!head) {
const node = new Node(value);
node.nxp = XOR(null, null);
return node;
} else {
const node = new Node(value);
const curr = head;
curr.nxp = XOR(node, XOR(null, curr.nxp));
node.nxp = XOR(null, curr);
return node;
}
}
// Function to print elements of the XOR Linked List
function printList(head) {
let curr = head;
let prev = null;
let next;
while (curr) {
console.log(curr.data);
next = XOR(prev, curr.nxp);
prev = curr;
curr = next;
}
}
// Function to reverse the XOR linked list
function reverse(head) {
let curr = head;
if (!curr) {
return null;
} else {
let prev = null;
let next;
while (XOR(prev, curr.nxp) !== null) {
next = XOR(prev, curr.nxp);
prev = curr;
curr = next;
}
head = curr;
return head;
}
}
// Driver Code
function main() {
let head = null;
// Create XOR Linked List: head-->40<-->30<-->20<-->10
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
console.log("XOR linked list:");
printList(head);
// Reverse the XOR Linked List: head-->10<-->20<-->30<-->40
head = reverse(head);
console.log("Reversed XOR linked list:");
printList(head);
}
// Call the main function
main();
OutputXOR linked list: 40 30 20 10
Reversed XOR linked list: 10 20 30 40
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
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
Reverse a Linked List
Given a linked list, the task is to reverse the linked list by changing the links between nodes.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> NULLOutput: head: 4 -> 3 -> 2 -> 1 -> NULLExplanation: Reversed Linked List: Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULLOut
15+ min read
Reverse a sublist of linked list
Given a linked list and positions m and n. We need to reverse the linked list from position m to n.Examples: Input : linkedlist : 10->20->30->40->50->60->70->NULL , m = 3 and n = 6Output : 10->20->60->50->40->30->70->NULLExplanation: Linkedlist reversed star
15+ 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
Reverse a linked list using recursion
Given a linked list, the task is to reverse the linked list by changing the links between nodes.Examples: Input: Linked List = 1 -> 2 -> 3 -> 4 -> NULL Output: 4 -> 3 -> 2 -> 1 -> NULLInput: Linked List = 1 -> 2 -> 3 -> 4 -> 5 -> NULL Output: 5 -> 4 -> 3
6 min read
Print Reverse a linked list using Stack
Given a linked list, print the reverse of it without modifying the list. Examples: Input : 1 2 3 4 5 6 Output : 6 5 4 3 2 1 Input : 12 23 34 45 56 67 78 Output : 78 67 56 45 34 23 12 Below are different solutions that are now allowed here as we cannot use extra space and modify the list. Recursive s
9 min read
Reverse each word in a linked list node
Given a linked list of strings, we need to reverse each word of the string in the given linked list. Examples: Input: geeksforgeeks a computer science portal for geeks Output: skeegrofskeeg a retupmoc ecneics latrop rof skeeg Input: Publish your own articles on geeksforgeeks Output: hsilbuP ruoy nwo
6 min read
Permutation of a Linked List
Given a singly linked list of distinct integers, the task is to generate all possible permutations of the linked list elements. Examples: Input: Linked List: 1 -> 2 -> 3Output: 1 -> 2 -> 31 -> 3 -> 22 -> 1 -> 32 -> 3 -> 13 -> 1 -> 23 -> 2 -> 1Input: Linked L
11 min read
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)
13 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