XOR Linked List – A Memory Efficient Doubly Linked List | Set 2

03 Jul, 2022
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 memory-efficient doubly linked list. We will mainly discuss the following two simple functions.
A function to insert a new node at the beginning.A function to traverse the list in forward direction.
A function to insert a new node at the beginning.
A function to traverse the list in forward direction.
In the following code, insert() function inserts a new node at the beginning. We need to change the head pointer of Linked List, that is why a double pointer is used (See this). Let us first discuss few things again that have been discussed in the previous post. We store XOR of next and previous nodes with every node and we call it npx, which is the only address member we have with every node. When we insert a new node at the beginning, npx of new node will always be XOR of NULL and current head. And npx of the current head must be changed to XOR of new node and node next to the current head.printList() traverses the list in forward direction. It prints data values from every node. To traverse the list, we need to get pointer to the next node at every point. We can get the address of next node by keeping track of current node and previous node. If we do XOR of curr->npx and prev, we get the address of next node. 
C++
C
Python3
/* C++ Implementation of Memory efficient Doubly Linked List */#include <bits/stdc++.h>#include <cinttypes> using namespace std;  // Node structure of a memory // efficient doubly linked list class Node {     public:    int data;     Node* npx; /* XOR of next and previous node */};   /* returns XORed value of the node addresses */Node* XOR (Node *a, Node *b) {     return reinterpret_cast<Node *>(      reinterpret_cast<uintptr_t>(a) ^       reinterpret_cast<uintptr_t>(b)); }   /* Insert a node at the beginning of the XORed linked list and makes the newly inserted node as head */void insert(Node **head_ref, int data) {     // Allocate memory for new node     Node *new_node = new Node();     new_node->data = data;       /* Since new node is being inserted at the     beginning, npx of new node will always be     XOR of current head and NULL */    new_node->npx = *head_ref;       /* If linked list is not empty, then npx of     current head node will be XOR of new node     and node next to current head */    if (*head_ref != NULL)     {         // *(head_ref)->npx is XOR of NULL and next.         // So if we do XOR of it with NULL, we get next         (*head_ref)->npx = XOR(new_node, (*head_ref)->npx);     }       // Change head     *head_ref = new_node; }   // prints contents of doubly linked // list in forward direction void printList (Node *head) {     Node *curr = head;     Node *prev = NULL;     Node *next;       cout << "Following are the nodes of Linked List: \n";       while (curr != NULL)     {         // print current node         cout<<curr->data<<" ";           // get address of next node: curr->npx is         // next^prev, so curr->npx^prev will be         // next^prev^prev which is next         next = XOR (prev, curr->npx);           // update prev and curr for next iteration         prev = curr;         curr = next;     } }   // Driver code int main () {     /* Create following Doubly Linked List     head-->40<-->30<-->20<-->10 */    Node *head = NULL;     insert(&head, 10);     insert(&head, 20);     insert(&head, 30);     insert(&head, 40);       // print the created list     printList (head);       return (0); }   // This code is contributed by rathbhupendra
/* C Implementation of Memory    efficient Doubly Linked List */#include <stdio.h>#include <stdlib.h>#include <inttypes.h>  // Node structure of a memory // efficient doubly linked liststruct Node{    int data;    struct Node* npx; /* XOR of next and previous node */};  /* returns XORed value of the node addresses */struct Node* XOR (struct Node *a, struct Node *b){    return (struct Node*) ((uintptr_t) (a) ^ (uintptr_t) (b));}  /* Insert a node at the beginning of the    XORed linked list and makes the newly   inserted node as head */void insert(struct Node **head_ref, int data){    // Allocate memory for new node    struct Node *new_node = (struct Node *) malloc (sizeof (struct Node) );    new_node->data = data;      /* Since new node is being inserted at the        beginning, npx of new node will always be       XOR of current head and NULL */    new_node->npx = *head_ref;      /* If linked list is not empty, then npx of        current head node will be XOR of new node       and node next to current head */    if (*head_ref != NULL)    {        // *(head_ref)->npx is XOR of NULL and next.         // So if we do XOR of it with NULL, we get next        (*head_ref)->npx = XOR(new_node, (*head_ref)->npx);    }      // Change head    *head_ref = new_node;}  // prints contents of doubly linked// list in forward directionvoid printList (struct Node *head){    struct Node *curr = head;    struct Node *prev = NULL;    struct Node *next;      printf ("Following are the nodes of Linked List: \n");      while (curr != NULL)    {        // print current node        printf ("%d ", curr->data);          // get address of next node: curr->npx is         // next^prev, so curr->npx^prev will be        // next^prev^prev which is next        next = XOR (prev, curr->npx);          // update prev and curr for next iteration        prev = curr;        curr = next;    }}  // Driver program to test above functionsint main (){    /* Create following Doubly Linked List    head-->40<-->30<-->20<-->10 */    struct Node *head = NULL;    insert(&head, 10);    insert(&head, 20);    insert(&head, 30);    insert(&head, 40);      // print the created list    printList (head);      return (0);}
# Python3 implementation of Memory# efficient Doubly Linked List  # library for providing C # compatible data typesimport ctypes  # Node class for memory# efficient doubly linked listclass Node:          def __init__(self, data):                  self.data = data                  # XOR of next and previous node        self.npx = 0    class XorLinkedList:          def __init__(self):                  self.head = None        self.__nodes = []              # Returns XORed value of the node addresses    def XOR(self, a, b):                  return a ^ b            # Insert a node at the beginning of the    # XORed linked list and makes the newly    # inserted node as head    def insert(self, data):                  # New node        node = Node(data)          # Since new node is being inserted at         # the beginning, npx of new node will        # always be XOR of current head and NULL        node.npx = id(self.head)          # If linked list is not empty, then        # npx of current head node will be         # XOR of new node and node next to        # current head        if self.head is not None:                          # head.npx is XOR of None and next.            # So if we do XOR of it with None,             # we get next            self.head.npx = self.XOR(id(node),                                      self.head.npx)          self.__nodes.append(node)                  # Change head        self.head = node      # Prints contents of doubly linked    # list in forward direction    def printList(self):                if self.head != None:            prev_id = 0            curr = self.head            next_id = 1                          print("Following are the nodes "                  "of Linked List:")                          while curr is not None:                                  # Print current node                print(curr.data, end = ' ')                                  # Get address of next node: curr.npx is                # next^prev, so curr.npx^prev will be                # next^prev^prev which is next                next_id = self.XOR(prev_id, curr.npx)                                  # Update prev and curr for next iteration                prev_id = id(curr)                curr = self.__type_cast(next_id)      # Method to return a new instance of type    # which points to the same memory block.    def __type_cast(self, id):                  return ctypes.cast(id, ctypes.py_object).value  # Driver codeif __name__ == '__main__':          obj = XorLinkedList()          # Create following Doubly Linked List    # head-->40<-->30<-->20<-->10    obj.insert(10)    obj.insert(20)    obj.insert(30)    obj.insert(40)      # Print the created list    obj.printList()  # This code is contributed by MuskanKalra1
Following are the nodes of Linked List: 
40 30 20 10
Note that XOR of pointers is not defined by C/C++ standard. So the above implementation may not work on all platforms.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
piyush02
rathbhupendra
shubham_singh
GaneshNawsupe1
j_tesla
MuskanKalra1
Accolite
Bitwise-XOR
doubly linked list
GE
Advanced Data Structure
Linked List
Accolite
GE
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
AVL Tree | Set 1 (Insertion)
Trie | (Insert and Search)
LRU Cache Implementation
Introduction of B-Tree
Red-Black Tree | Set 1 (Introduction)
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)