Memory efficient doubly linked list
Last Updated :
29 Aug, 2024
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 linked list and the getList() function returns the linked list as a list.
Note: The List should be printed in both forward and backward direction.
Examples
Input: head= 40<->30<->20<->10
Output: 40 30 20 10
10 20 30 40
Input: head= 5<->4<->3<->2<->1
Output: 5 4 3 2 1
1 2 3 4 5
[Expected Approach] Using Bitwise XOR - O(n) Time and O(1) Space
We know that each node in a doubly-linked list has two pointer fields which contain the addresses of the previous and next node. On the other hand, each node of the XOR linked list requires only a single pointer field, which doesn’t store the actual memory addresses but stores the bitwise XOR of addresses for its previous and next node.
Below is the implementation of the above approach :
C++
// C++ program Implements a doubly linked
// list using XOR pointers.
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* npx;
Node(int x) {
data = x;
npx = nullptr;
}
};
// XOR function to get XOR of two pointers
Node* XOR(Node* a, Node* b) {
return reinterpret_cast<Node*>(reinterpret_cast<uintptr_t>(a)
^ reinterpret_cast<uintptr_t>(b));
}
// Function to insert a node at the front of the list
Node* insert(Node* head, int data) {
// Create a new node with the given data
Node* new_node = new Node(data);
// Make the new node's npx point to the head
new_node->npx = XOR(head, nullptr);
// Update npx of the head if it's not NULL
if (head != nullptr) {
Node* next = XOR(head->npx, nullptr);
head->npx = XOR(new_node, next);
}
// Return the new node as the new head
return new_node;
}
// Function to retrieve the list as a vector
vector<int> getList(Node* head) {
vector<int> vec;
Node* curr = head;
Node* prev = nullptr;
Node* next;
while (curr != nullptr) {
// Add current node's data to vector
vec.push_back(curr->data);
// Calculate the next node using XOR
next = XOR(prev, curr->npx);
// Update previous and current nodes
prev = curr;
curr = next;
}
return vec;
}
int main() {
// Create a hard-coded linked list:
// 40 <-> 30 <-> 20 <-> 10 (since we insert at the
// front)
Node* head = nullptr;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
vector<int> list = getList(head);
for(int i = 0; i < list.size(); ++i) {
cout<< list[i] <<" ";
}
cout << endl;
for(int i = list.size() - 1; i >= 0; --i) {
cout<< list[i] <<" ";
}
cout << endl;
return 0;
}
// C program Implements a doubly linked
// list using XOR pointers
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
struct Node {
int data;
struct Node* npx;
};
struct Node* createNode(int data);
// XOR function to get XOR of two pointers
struct Node* XOR(struct Node* a, struct Node* b) {
return (struct Node*)((uintptr_t)(a) ^ (uintptr_t)(b));
}
// Function to insert a node at the front of the list
struct Node* insert(struct Node* head, int data) {
// Create a new node with the given data
struct Node* new_node = createNode(data);
// Make the new node's npx point to the head
new_node->npx = XOR(head, NULL);
// Update npx of the head if it's not NULL
if (head != NULL) {
struct Node* next = XOR(head->npx, NULL);
head->npx = XOR(new_node, next);
}
// Return the new node as the new head
return new_node;
}
// Function to retrieve the list as an array
void getList(struct Node* head, int* arr, int* len) {
struct Node* curr = head;
struct Node* prev = NULL;
struct Node* next;
// Initialize array index
*len = 0;
while (curr != NULL) {
// Add current node's data to array
arr[(*len)++] = curr->data;
// Calculate the next node using XOR
next = XOR(prev, curr->npx);
// Update previous and current nodes
prev = curr;
curr = next;
}
}
struct Node* createNode(int data) {
struct Node* new_node =
(struct Node*)malloc(sizeof(struct Node));
new_node->data = data;
new_node->npx = NULL;
return new_node;
}
int main() {
// Create a hard-coded linked list:
// 40 <-> 30 <-> 20 <-> 10 (since we insert at the
// front)
struct Node* head = NULL;
int list[100];
int len, i;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
getList(head, list, &len);
for (i = 0; i < len; ++i) {
printf("%d ", list[i]);
}
printf("\n");
for (i = len - 1; i >= 0; --i) {
printf("%d ", list[i]);
}
printf("\n");
return 0;
}
// Java program Implements a doubly linked
// list using XOR pointers
import java.util.ArrayList;
class Node {
int data;
Node prev;
Node next;
Node(int x) {
this.data = x;
this.prev = null;
this.next = null;
}
}
public class GfG {
// Function to insert a node at the front
static Node insert(Node head, int data) {
// Create a new node with the given data
Node newNode = new Node(data);
// Update head's previous pointer if the list is not
// empty
if (head != null) {
head.prev = newNode;
newNode.next = head;
}
// Return the new node as the new head
return newNode;
}
// Function to retrieve the list as an ArrayList
static ArrayList<Integer> getList(Node head) {
ArrayList<Integer> list = new ArrayList<>();
// Start from the head and traverse the list
Node current = head;
while (current != null) {
list.add(current.data);
current = current.next;
}
return list;
}
public static void main(String[] args) {
// Create a hard-coded linked list:
// 40 <-> 30 <-> 20 <-> 10 (since we insert at the
// front)
Node head = null;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
ArrayList<Integer> list = getList(head);
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
for (int i = list.size() - 1; i >= 0; i--) {
System.out.print(list.get(i) + " ");
}
System.out.println();
}
}
# Python program Implements a doubly linked
# list using XOR pointers
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
# Function to insert a node at the front
def insert(head, data):
# Create a new node with the given data
new_node = Node(data)
# Update head's previous pointer if list is not empty
if head is not None:
head.prev = new_node
new_node.next = head
# Return the new node as the new head
return new_node
# Function to retrieve the list as a list
def getList(head):
result = []
# Start from the head and traverse the list
current = head
while current is not None:
result.append(current.data)
current = current.next
return result
if __name__ == "__main__":
# Create a hard-coded linked list:
# 40 <-> 30 <-> 20 <-> 10 (since we insert at the
# front)
head = None
head = insert(head, 10)
head = insert(head, 20)
head = insert(head, 30)
head = insert(head, 40)
result_list = getList(head)
for i in range(len(result_list)):
print(result_list[i], end=" ")
print()
for i in range(len(result_list) - 1, -1, -1):
print(result_list[i], end=" ")
print()
// C# program Implements a doubly linked
// list using XOR pointers
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node prev;
public Node next;
public Node(int x) {
data = x;
prev = null;
next = null;
}
}
class GfG {
// Function to insert a node at the front
static Node Insert(Node head, int data) {
// Create a new node with the given data
Node newNode = new Node(data);
// Update head's previous pointer if
// the list is not empty
if (head != null) {
head.prev = newNode;
newNode.next = head;
}
// Return the new node as the new head
return newNode;
}
// Function to retrieve the list as a List<int>
static List<int> GetList(Node head) {
List<int> result = new List<int>();
// Start from the head and traverse the list
Node current = head;
while (current != null) {
result.Add(current.data);
current = current.next;
}
return result;
}
public static void Main(string[] args) {
// Create a hard-coded linked list:
// 40 <-> 30 <-> 20 <-> 10
//(since we insert at the front)
Node head = null;
head = Insert(head, 10);
head = Insert(head, 20);
head = Insert(head, 30);
head = Insert(head, 40);
List<int> resultList = GetList(head);
foreach (int num in resultList) {
Console.Write(num + " ");
}
Console.WriteLine();
for (int i = resultList.Count - 1; i >= 0; i--) {
Console.Write(resultList[i] + " ");
}
Console.WriteLine();
}
}
// Javascript program Implements a doubly linked
// list using XOR pointers
class Node {
constructor(data) {
// Initialize node data and pointers
this.data = data;
this.prev = null;
this.next = null;
}
}
// Function to insert a node at the front
function insert(head, data) {
// Create a new node with the given data
const newNode = new Node(data);
// Update head's previous pointer if list is not empty
if (head !== null) {
head.prev = newNode;
newNode.next = head;
}
// Return the new node as the new head
return newNode;
}
// Function to retrieve the list as an array
function getList(head) {
const result = [];
// Start from the head and traverse the list
let current = head;
while (current !== null) {
result.push(current.data);
current = current.next;
}
return result;
}
// Create a hard-coded linked list:
// 40 <-> 30 <-> 20 <-> 10 (since we insert at the
// front)
let head = null;
head = insert(head, 10);
head = insert(head, 20);
head = insert(head, 30);
head = insert(head, 40);
const resultList = getList(head);
for (let i = 0; i < resultList.length; i++) {
console.log(resultList[i] + " ");
}
for (let i = resultList.length - 1; i >= 0; i--) {
console.log(resultList[i] + " ");
}
Output40 30 20 10
10 20 30 40
Time Complexity: O(n) for both insertion and retrieval, where n is the number of nodes.
Auxiliary Space: O(1) for insertion, O(n) for storing the list in an array
Related articles :
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