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.

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

/* 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 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

import java.util.*;

// Node structure of a memory efficient doubly linked list
class Node {
    public int data;
    public Node npx; // XOR of next and previous node
}

public class Main {
    /* returns XORed value of the node addresses */
    public static Node XOR (Node a, Node b) {
        return (Node) (a ^ b);
    }

    /* Insert a node at the beginning of the
       XORed linked list and makes the newly
       inserted node as head */
    public static 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[0];

        /* 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[0] != null) {
            // *(head_ref)->npx is XOR of NULL and next.
            // So if we do XOR of it with NULL, we get next
            head_ref[0].npx = XOR(new_node, head_ref[0].npx);
        }

        // Change head
        head_ref[0] = new_node;
    }

    // prints contents of doubly linked list in forward direction
    public static void printList (Node head) {
        Node curr = head;
        Node prev = null;
        Node next;

        System.out.println("Following are the nodes of Linked List: ");

        while (curr != null) {
            // print current node
            System.out.print(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
    public static void main (String[] args) {
        /* Create 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

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)

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above