XOR Linked List – A Memory Efficient Doubly Linked List | Set 2
Last Updated :
30 Apr, 2024
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.
- A function to insert a new node at the beginning.
- 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
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h> // Include stdint.h for uintptr_t
// Node structure of a memory-efficient doubly linked list
typedef struct Node {
int data;
struct Node* npx; // XOR of next and previous node
} Node;
// XOR function for C (casted pointer XOR)
Node* XOR(Node* a, Node* b) {
return (Node*)((uintptr_t)a ^ (uintptr_t)b);
}
// Insert a node at the beginning of the XORed linked list
Node* insert(Node* head_ref, int data) {
Node* new_node = (Node*)malloc(sizeof(Node));
new_node->data = data;
new_node->npx = head_ref;
if (head_ref != NULL) {
head_ref->npx = XOR(new_node, head_ref->npx);
}
return new_node; // Return new node as the updated head
}
// Print contents of doubly linked list in forward direction
void printList(Node* head) {
Node* curr = head;
Node* prev = NULL;
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 XOR of prev and next
next = XOR(prev, curr->npx);
// Update prev and curr for next iteration
prev = curr;
curr = next;
}
printf("\n");
}
// Driver code
int main() {
/* Create following Doubly Linked List
head-->40<-->30<-->20<-->10 */
Node* head = NULL;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
// Print the created list
printList(head);
return 0;
}
// Node structure of a memory-efficient doubly linked list
class Node {
int data;
Node npx; // XORed value of the addresses of previous
// and next nodes
// Constructor
public Node(int data)
{
this.data = data;
this.npx = null;
}
}
public class Main {
// Returns XORed value of the node addresses
static Node XOR(Node a, Node b)
{
// Converting node addresses to integers and
// performing XOR operation
return new Node(System.identityHashCode(a)
^ System.identityHashCode(b));
}
// Insert a node at the beginning of the XORed linked
// list and makes the newly inserted node as head
static void insert(Node head_ref, int data)
{
// Allocate memory for new node
Node new_node = new Node(data);
// Since the new node is being inserted at the
// beginning, npx of the 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
new_node.npx = XOR(new_node, head_ref.npx);
}
// Change head
head_ref = new_node;
}
// Prints contents of doubly linked list in forward
// direction
static void printList(Node head)
{
System.out.println(
"Following are the nodes of Linked List: ");
Node curr = head;
Node prev = null;
Node next;
while (curr != null) {
// Print current node
System.out.println(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)
{
Node head = null;
insert(head, 10);
insert(head, 20);
insert(head, 30);
insert(head, 40);
// Print the created list
printList(head);
}
}
# 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
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
}
}
class Node {
constructor(data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
// Insert a node at the beginning of the linked list
function insert(head, data) {
let new_node = new Node(data);
if (head !== null) {
new_node.next = head;
head.prev = new_node;
}
return new_node; // Return the new node as the updated head
}
// Print contents of doubly linked list in forward direction
function printList(head) {
let curr = head;
let result = "Following are the nodes of Linked List:\n";
while (curr !== null) {
// Print current node
result += curr.data + " ";
curr = curr.next;
}
console.log(result);
}
// Driver code
let head = null;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
printList(head);
OutputFollowing 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)
Similar Reads
Doubly Linked List meaning in DSA A doubly linked list is a special type of linked list in which each node contains a pointer to the previous node as well as the next node in the structure. Doubly Linked ListCharacteristics of the Doubly Linked List: The characteristics of a doubly linked list are as follows: Dynamic size: The size
3 min read
Doubly Linked List Tutorial A doubly linked list is a more complex data structure than a singly linked list, but it offers several advantages. The main advantage of a doubly linked list is that it allows for efficient traversal of the list in both directions. This is because each node in the list contains a pointer to the prev
8 min read
Difference between Singly linked list and Doubly linked list Introduction to Singly linked list : A singly linked list is a set of nodes where each node has two fields 'data' and 'link'. The 'data' field stores actual piece of information and 'link' field is used to point to next node. Basically the 'link' field stores the address of the next node. Introducti
2 min read
Applications, Advantages and Disadvantages of Doubly Linked List Doubly linked list is a type of linked list in which nodes contains information and two pointers i.e. left pointer and right pointer. The left pointer in the doubly linked list points to the previous node and the right pointer points to the next node in the linked list. The first node of the doubly
4 min read
Operations on Doubly Linked
Operations of Doubly Linked List with ImplementationA Doubly Linked List (DLL) contains an extra pointer, typically called the previous pointer, together with the next pointer and data which are there in a singly linked list. Below are operations on the given DLL: Add a node at the front of DLL: The new node is always added before the head of the giv
15+ min read
Insertion in a Doubly Linked ListInserting a new node in a doubly linked list is very similar to inserting new node in linked list. There is a little extra work required to maintain the link of the previous node. In this article, we will learn about different ways to insert a node in a doubly linked list.Table of ContentInsertion a
6 min read
Search an element in a Doubly Linked ListGiven a Doubly linked list(DLL) containing n nodes and an integer x, the task is to find the position of the integer x in the doubly linked list. If no such position found then print -1.Examples:Input: Linked List = 18 <-> 15 <-> 8 <-> 9 <-> 14, x = 8 Output: 3 Explanation: x
7 min read
Deletion in a Doubly Linked ListDeleting a node in a doubly linked list is very similar to deleting a node in a singly linked list. However, there is a little extra work required to maintain the links of both the previous and next nodes. In this article, we will learn about different ways to delete a node in a doubly linked list.E
15+ min read
Delete a Doubly Linked List node at a given positionGiven a doubly linked list and a position pos, the task is to delete the node at the given position from the beginning of Doubly Linked List.Input: LinkedList: 1<->2<->3, pos = 2Output: LinkedList: 1<->3Input: LinkedList: 1<->2<->3, pos = 1Output: LinkedList: 2<->
9 min read
Doubly Linked List in Different Languages
How to Create a Doubly Linked List in C? A doubly linked list is a type of linked list in which each node contains a pointer to both the next node and the previous node. This allows traversal in both forward and backward directions. Each node in a doubly linked list stores data, a pointer to the next node, and a pointer to the previous nod
4 min read
Introduction to Doubly Linked Lists in Java Doubly linked list is a data structure that has reference to both the previous and next nodes in the list. It provides simplicity to traverse, insert and delete the nodes in both directions in a list. In a doubly linked list, each node contains three data members: data: The data stored in the nodene
11 min read
Implementation of Doubly Linked List in JavaScript This article will demonstrate the Implementation of Doubly Linked List In JavaScript. A doubly linked list (DLL) is a special type of linked list in which each node contains a pointer to the previous node as well as the next node of the linked list. Doubly Linked List in JavaScriptTo create we have
4 min read
Memory efficient doubly linked list We need to implement a doubly linked list with the use of a single pointer in each node. For that we are given a stream of data of size n for the linked list, your task is to make the function insert() and getList(). The insert() function pushes (or inserts at the beginning) the given data in the li
9 min read