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

1. A function to insert a new node at the beginning.
2. A function to traverse the list in a forwarding direction.
Recommended Practice

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 a few things again that have been discussed in the previous post. We store XOR of the 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 the new node will always be XOR of NULL and the current head. And npx of the current head must be changed to XOR of the new node and node next to the current head.
printList() traverses the list in a forwarding direction. It prints data values from every node. To traverse the list, we need to get a pointer to the next node at every point. We can get the address of next node by keeping track of the current node and previous node. If we do XOR of curr->npx and prev, we get the address of next node.

Implementation:

## C++

 `/* C++ Implementation of Memory ``efficient Doubly Linked List */``#include ``#include ``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``(``      ``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<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

 `/* C Implementation of Memory ``   ``efficient Doubly Linked List */``#include ``#include ``#include ` `// Node structure of a memory ``// efficient doubly linked list``struct` `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 direction``void` `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 functions``int` `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);``}`

## Java

 `class` `Node {``    ``public` `int` `data;``    ``public` `Node prev;``    ``public` `Node next;` `    ``public` `Node(``int` `data) {``        ``this``.data = data;``        ``this``.prev = ``null``;``        ``this``.next = ``null``;``    ``}``}` `public` `class` `Main {``    ``/* Insert a node at the beginning of the doubly linked list */``    ``public` `static` `void` `insert(Node[] head_ref, ``int` `data) {``        ``Node new_node = ``new` `Node(data);` `        ``new_node.next = head_ref[``0``];``        ``new_node.prev = ``null``;` `        ``if` `(head_ref[``0``] != ``null``) {``            ``head_ref[``0``].prev = new_node;``        ``}` `        ``head_ref[``0``] = new_node;``    ``}` `    ``// prints contents of doubly linked list in forward direction``    ``public` `static` `void` `printList(Node head) {``        ``Node curr = head;` `        ``System.out.println(``"Following are the nodes of Linked List: "``);` `        ``while` `(curr != ``null``) {``            ``// print current node``            ``System.out.print(curr.data + ``" "``);` `            ``// move to the next node``            ``curr = curr.next;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``/* Create the following Doubly Linked List``           ``head-->40<-->30<-->20<-->10 */``        ``Node[] head = ``new` `Node[``1``];``        ``insert(head, ``10``);``        ``insert(head, ``20``);``        ``insert(head, ``30``);``        ``insert(head, ``40``);` `        ``// print the created list``        ``printList(head[``0``]);``    ``}``}`

## Python3

 `# Python3 implementation of Memory``# efficient Doubly Linked List` `# library for providing C ``# compatible data types``import` `ctypes` `# Node class for memory``# efficient doubly linked list``class` `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 code``if` `__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`

## C#

 `using` `System;` `// Node structure of a doubly linked list``class` `Node``{``    ``public` `int` `data;``    ``public` `Node prev;``    ``public` `Node next;``}` `class` `Program``{``    ``// Insert a node at the beginning of the linked list``    ``static` `void` `Insert(``ref` `Node head_ref, ``int` `data)``    ``{``        ``// Allocate memory for new node``        ``Node new_node = ``new` `Node();``        ``new_node.data = data;` `        ``// Set the next of the new node as the current head``        ``new_node.next = head_ref;` `        ``// If the current head is not null, set the previous of the head as the new node``        ``if` `(head_ref != ``null``)``            ``head_ref.prev = new_node;` `        ``// Set the new node as the head``        ``head_ref = new_node;``    ``}` `    ``// Prints the contents of the linked list in forward direction``    ``static` `void` `PrintList(Node head)``    ``{``        ``Console.WriteLine(``"Following are the nodes of Linked List: "``);` `        ``while` `(head != ``null``)``        ``{``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``    ``}` `    ``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``/* Create following Doubly Linked List ``           ``head-->40<-->30<-->20<-->10 */``        ``Node head = ``null``;``        ``Insert(``ref` `head, 10);``        ``Insert(``ref` `head, 20);``        ``Insert(``ref` `head, 30);``        ``Insert(``ref` `head, 40);` `        ``// Print the created list``        ``PrintList(head);` `        ``// This code is contributed by Shivam Tiwari``    ``}``}`

## Javascript

 `// Node structure of a memory``// efficient doubly linked list``class Node {``    ``constructor(data, npx) {``        ``this``.data = data;``        ``this``.npx = npx;``    ``}``}` `/* returns XORed value of the node addresses */``function` `XOR(a, b) {``    ``return` `(a ^ b);``}` `/* Insert a node at the beginning of the``XORed linked list and makes the newly``inserted node as head */``function` `insert(head_ref, data) {``    ``// Allocate memory for new node``    ``let new_node = ``new` `Node(data, ``null``);` `    ``/* 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``function` `printList(head) {``    ``let curr = head;``    ``let prev = ``null``;``    ``let next;` `    ``console.log(``"Following are the nodes of Linked List: "``);` `    ``while` `(curr != ``null``) {``        ``// print current node``        ``console.log(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``let head = ``null``;``insert(head, 10);``insert(head, 20);``insert(head, 30);``insert(head, 40);` `// print the created list``printList(head);`

Output
```Following are the nodes of Linked List:
40 30 20 10

```

Time Complexity: O(n), Where n is the total number of nodes in the given Doubly Linked List
Auxiliary Space: O(1)

Previous
Next