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 < – > 7Input: XLL = NULL
Output: List Is Empty
Approach: The idea is to update the head node of the XOR linked list to the second node of the XOR linked list and delete memory allocated for the first node. Follow the steps below to solve the problem:
- Check if the XOR linked list is empty or not. If found to be true, then print “List Is Empty”.
- Otherwise, update the head node of the XOR linked list to the second node of the linked list.
- Delete the first node from memory.
Below is the implementation of the above approach:
// C program to implement // 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 address 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)
{ // Check 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;
}
} // Function to remove the first node from // the given linked list struct Node* delBeginning( struct Node** head)
{ // If list is empty
if (*head == NULL)
printf ( "List Is Empty" );
else {
// Store the node to be deleted
struct Node* temp = *head;
// Update the head pointer
*head = XOR(NULL, temp->nxp);
// When the linked list
// contains only one node
if (*head != NULL) {
// Update head node address
(*head)->nxp
= XOR(NULL, XOR(temp,
(*head)->nxp));
}
free (temp);
}
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);
// Delete the first node
delBeginning(&head);
/* Print the following XOR Linked List
head-->30<-->20<-->10 */
printList(&head);
return (0);
} |
#include <iostream> #include <cstdlib> using namespace std;
// Structure of a node in XOR linked list struct Node {
int data;
struct Node* nxp;
}; // Function to find the XOR of address 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)
{ // Check 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
cout << curr->data << " " ;
// Forward traversal
next = XOR(prev, curr->nxp);
// Update prev
prev = curr;
// Update curr
curr = next;
}
} // Function to remove the first node from the given linked list struct Node* delBeginning( struct Node** head)
{ // If list is empty
if (*head == NULL)
cout << "List Is Empty" ;
else
{
// Store the node to be deleted
struct Node* temp = *head;
// Update the head pointer
*head = XOR(NULL, temp->nxp);
// When the linked list contains only one node
if (*head != NULL)
{
// Update head node address
(*head)->nxp = XOR(NULL, XOR(temp, (*head)->nxp));
}
free (temp);
}
return *head;
} 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); // Delete the first node delBeginning(&head); /* Print the following XOR Linked List head-->30<-->20<-->10 */ printList(&head); return (0);
} // This code is contributed by lokeshpotta20. |
import java.util.HashMap;
import java.util.Map;
class Node {
int data;
int npx;
Node( int data) {
this .data = data;
this .npx = 0 ;
}
} class XorLinkedList {
Node head;
Node[] nodes;
XorLinkedList() {
head = null ;
nodes = new Node[ 100 ]; // assuming 100 as max number of nodes
}
void insert( int data) {
Node node = new Node(data);
nodes[data - 1 ] = node; // assuming data starts from 1 and is unique
if (head != null ) {
node.npx = getPointer(head);
head.npx = getPointer(node) ^ head.npx;
}
head = node;
}
void removeHead() {
if (head == null ) {
System.out.println( "List Is Empty" );
return ;
}
int nextNodeId = head.npx;
if (nextNodeId != 0 ) {
Node nextNode = dereferencePointer(nextNodeId);
nextNode.npx ^= getPointer(head);
nodes[head.data - 1 ] = null ; // removing head node from nodes array
head = nextNode;
}
}
void printList() {
Node current = head;
int prevAddr = 0 ;
while (current != null ) {
System.out.println(current.data);
int nextAddr = prevAddr ^ current.npx;
prevAddr = getPointer(current);
current = dereferencePointer(nextAddr);
}
}
int getPointer(Node node) {
// Using System.identityHashCode to get a unique identifier for the node object
return System.identityHashCode(node);
}
Node dereferencePointer( int address) {
for ( int i = 0 ; i < nodes.length; i++) {
if (nodes[i] != null && getPointer(nodes[i]) == address) {
return nodes[i];
}
}
return null ;
}
} public class Main {
public static void main(String[] args) {
XorLinkedList xll = new XorLinkedList();
xll.insert( 10 );
xll.insert( 20 );
xll.insert( 30 );
xll.insert( 40 );
xll.removeHead();
xll.printList();
}
} |
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 remove the first node from the given linked list
def delBeginning( self ):
# If list is empty
if self .isEmpty():
return "List is empty !"
# If list has 1 node
elif self .head = = self .tail:
self .head = self .tail = None
# If list has 2 nodes
elif ( 0 ^ self .head.npx) = = id ( self .tail):
self .head = self .tail
self .head.npx = self .tail.npx = 0
# If list has more than 2 nodes
else :
# Store the node to be deleted
res = self .head.value
# Address of next node
x = self .__type_cast( 0 ^ self .head.npx)
# Address of next of next node
y = ( id ( self .head) ^ x.npx)
self .head = x
self .head.npx = 0 ^ y
return res
# Create following XOR Linked List # head-->40<-->30<-->20<-->10 head = XorLinkedList()
head.insert( 10 )
head.insert( 20 )
head.insert( 30 )
head.insert( 40 )
# Delete the first node head.delBeginning(); # Print the following XOR Linked List # head-->30<-->20<-->10 head.printList(); # This code is contributed by Nighi goel. |
using System;
class Node {
public int data;
public int npx;
public Node( int data) {
this .data = data;
this .npx = 0;
}
} class XorLinkedList {
private Node head;
private Node[] nodes;
public XorLinkedList() {
head = null ;
nodes = new Node[100]; // assuming 100 as max number of nodes
}
public void insert( int data) {
Node node = new Node(data);
nodes[data - 1] = node; // assuming data starts from 1 and is unique
if (head != null ) {
node.npx = getPointer(head);
head.npx = getPointer(node) ^ head.npx;
}
head = node;
}
public void removeHead() {
if (head == null ) {
Console.WriteLine( "List Is Empty" );
return ;
}
int nextNodeId = head.npx;
if (nextNodeId != 0) {
Node nextNode = dereferencePointer(nextNodeId);
nextNode.npx ^= getPointer(head);
nodes[head.data - 1] = null ; // removing head node from nodes array
head = nextNode;
}
}
public void printList() {
Node current = head;
int prevAddr = 0;
while (current != null ) {
Console.WriteLine(current.data);
int nextAddr = prevAddr ^ current.npx;
prevAddr = getPointer(current);
current = dereferencePointer(nextAddr);
}
}
private int getPointer(Node node) {
// Using RuntimeHelpers.GetHashCode to get a unique identifier for the node object
return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(node);
}
private Node dereferencePointer( int address) {
for ( int i = 0; i < nodes.Length; i++) {
if (nodes[i] != null && getPointer(nodes[i]) == address) {
return nodes[i];
}
}
return null ;
}
} public class Program {
public static void Main() {
XorLinkedList xll = new XorLinkedList();
xll.insert(10);
xll.insert(20);
xll.insert(30);
xll.insert(40);
xll.removeHead();
xll.printList();
}
} |
class Node { constructor(data) {
this .data = data;
this .npx = 0;
}
} class XorLinkedList { constructor() {
this .head = null ;
this .nodes = [];
}
insert(data) {
let node = new Node(data);
this .nodes.push(node);
if ( this .head !== null ) {
node.npx = getPointer( this .head);
this .head.npx = getPointer(node) ^ this .head.npx;
}
this .head = node;
}
removeHead() {
if (! this .head) {
console.log( "List Is Empty" );
return ;
}
let nextNodeId = this .head.npx;
if (nextNodeId !== 0) {
let nextNode = dereferencePointer(nextNodeId);
nextNode.npx ^= getPointer( this .head);
delete this .nodes[ this .nodes.indexOf( this .head)];
delete this .head;
this .head = nextNode;
}
}
printList() {
let current = this .head;
let prevAddr = 0;
while (current != null ) {
console.log(current.data);
let nextAddr = prevAddr ^ current.npx;
prevAddr = getPointer(current);
current = dereferencePointer(nextAddr);
}
}
} let addressMap = new Map();
let addressCount = 1; function getPointer(object) {
if (addressMap.has(object)) return addressMap.get(object);
let newAddressCountValue = addressCount++;
addressMap.set(object, newAddressCountValue);
return newAddressCountValue;
} function dereferencePointer(address) {
for (let [key, value] of addressMap.entries()) {
if (value === address) return key;
}
return undefined
} let xll = new XorLinkedList();
xll.insert(10); xll.insert(20); xll.insert(30); xll.insert(40); xll.removeHead(); xll.printList(); |
30 20 10
Time Complexity: O(1)
Auxiliary Space: O(1)