Open In App

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

Input: 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

 `// C program to implement``// the above approach``#include ``#include ``#include ` `// 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);``}`

## C++

 `#include ``#include ``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.`

## Java

 `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();``    ``}``}`

## Python3

 `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.`

## C#

 `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();``    ``}``}`

## Javascript

 `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();`

Output:

`30 20 10`

Time Complexity: O(1)
Auxiliary Space: O(1)