Doubly Linked List Tutorial - GeeksforGeeks (2024)

struct Node { // To store the Value or data. int data; // Pointer to point the Previous Element Node* prev; // Pointer to point the Next Element Node* next;};

#include <iostream>using namespace std;// Define the Node structurestruct Node { int data; // Data stored in the node Node* next; // Pointer to the next node in the list Node* prev; // Pointer to the previous node in the list // Constructor to initialize Node with data Node(int data) : data(data), next(nullptr), prev(nullptr) {}};// Function to traverse the doubly linked list in forward directionvoid forwardTraversal(Node* head) { // Start traversal from the head of the list Node* current = head; // Continue until current node is not null (end of list) while (current != nullptr) { // Output data of the current node cout << current->data << " "; // Move to the next node current = current->next; } // Print newline after traversal cout << endl;}// Function to traverse the doubly linked list in backward directionvoid backwardTraversal(Node* tail) { // Start traversal from the tail of the list Node* current = tail; // Continue until current node is not null (end of list) while (current != nullptr) { // Output data of the current node cout << current->data << " "; // Move to the previous node current = current->prev; } // Print newline after traversal cout << endl;}int main() { // Sample usage of the doubly linked list and traversal functions Node* head = new Node(1); Node* second = new Node(2); Node* third = new Node(3); head->next = second; second->prev = head; second->next = third; third->prev = second; cout << "Forward Traversal:" << endl; forwardTraversal(head); cout << "Backward Traversal:" << endl; backwardTraversal(third); // Free memory allocated for nodes delete head; delete second; delete third; return 0;}

class Node { int data; Node next; Node prev; public Node(int data) { this.data = data; this.next = null; this.prev = null; }}public class DoublyLinkedListTraversal { // Function to traverse the doubly linked list in forward direction static void forwardTraversal(Node head) { // Start traversal from the head of the list Node current = head; // Continue until the current node is not null (end of the list) while (current != null) { // Output data of the current node System.out.print(current.data + " "); // Move to the next node current = current.next; } // Print newline after traversal System.out.println(); } // Function to traverse the doubly linked list in backward direction static void backwardTraversal(Node tail) { // Start traversal from the tail of the list Node current = tail; // Continue until the current node is not null (end of the list) while (current != null) { // Output data of the current node System.out.print(current.data + " "); // Move to the previous node current = current.prev; } // Print newline after traversal System.out.println(); } public static void main(String[] args) { // Sample usage of the doubly linked list and traversal functions Node head = new Node(1); Node second = new Node(2); Node third = new Node(3); head.next = second; second.prev = head; second.next = third; third.prev = second; System.out.println("Forward Traversal:"); forwardTraversal(head); System.out.println("Backward Traversal:"); backwardTraversal(third); }}

class Node: def __init__(self, data): self.data = data self.next = None self.prev = None# Function to traverse the doubly linked list in forward directiondef forward_traversal(head): # Start traversal from the head of the list current = head # Continue until the current node is not None (end of the list) while current is not None: # Output data of the current node print(current.data, end=" ") # Move to the next node current = current.next # Print newline after traversal print()# Function to traverse the doubly linked list in backward directiondef backward_traversal(tail): # Start traversal from the tail of the list current = tail # Continue until the current node is not None (end of the list) while current is not None: # Output data of the current node print(current.data, end=" ") # Move to the previous node current = current.prev # Print newline after traversal print()# Sample usage of the doubly linked list and traversal functionshead = Node(1)second = Node(2)third = Node(3)head.next = secondsecond.prev = headsecond.next = thirdthird.prev = secondprint("Forward Traversal:")forward_traversal(head)print("Backward Traversal:")backward_traversal(third)

class Node { constructor(data) { this.data = data; this.next = null; this.prev = null; }}// Function to traverse the doubly linked list in forward directionfunction forwardTraversal(head) { // Start traversal from the head of the list let current = head; // Continue until the current node is not null (end of the list) while (current !== null) { // Output data of the current node process.stdout.write(current.data + " "); // Move to the next node current = current.next; } // Print newline after traversal console.log();}// Function to traverse the doubly linked list in backward directionfunction backwardTraversal(tail) { // Start traversal from the tail of the list let current = tail; // Continue until the current node is not null (end of the list) while (current !== null) { // Output data of the current node process.stdout.write(current.data + " "); // Move to the previous node current = current.prev; } // Print newline after traversal console.log();}// Sample usage of the doubly linked list and traversal functionslet head = new Node(1);let second = new Node(2);let third = new Node(3);head.next = second;second.prev = head;second.next = third;third.prev = second;console.log("Forward Traversal:");forwardTraversal(head);console.log("Backward Traversal:");backwardTraversal(third);

// Node structure for doubly linked liststruct Node { int data; // Data stored in the node Node* prev; // Pointer to the previous node Node* next; // Pointer to the next node // Constructor to initialize node with given value Node(int val) : data(val) , prev(nullptr) , next(nullptr) { }};// Function to find the length of a doubly linked listint findLength(Node* head){ // Variable to store the length of the list int length = 0; // Pointer to traverse the list Node* current = head; // Traverse the list until reaching the end while (current != nullptr) { // Increment length for each node visited length++; // Move to the next node current = current->next; } // Return the length of the list return length;}

// Node structure for doubly linked listclass Node { constructor(data) { this.data = data; // Data stored in the node this.prev = null; // Pointer to the previous node this.next = null; // Pointer to the next node }}// Function to find the length of a doubly linked listfunction findLength(head) { let length = 0; // Variable to store the length of the list let current = head; // Pointer to traverse the list // Traverse the list until reaching the end while (current !== null) { length++; // Increment length for each node visited current = current.next; // Move to the next node } return length; // Return the length of the list}

# Node class for doubly linked listclass Node: def __init__(self, val): # Data stored in the node self.data = val # Pointer to the previous node self.prev = None # Pointer to the next node self.next = None# Function to find the length of a doubly linked listdef find_length(head): # Variable to store the length of the list length = 0 # Pointer to traverse the list current = head # Traverse the list until reaching the end while current is not None: # Increment length for each node visited length += 1 # Move to the next node current = current.next # Return the length of the list return length

// Node class for doubly linked listclass Node { constructor(val) { this.data = val; // Data stored in the node this.prev = null; // Pointer to the previous node this.next = null; // Pointer to the next node }}// Function to find the length of a doubly linked listfunction findLength(head) { // Variable to store the length of the list let length = 0; // Pointer to traverse the list let current = head; // Traverse the list until reaching the end while (current !== null) { // Increment length for each node visited length++; // Move to the next node current = current.next; } // Return the length of the list return length;}

// Define the structure for a node in the doubly linked liststruct Node { int data; // Data stored in the node Node* next; // Pointer to the next node Node* prev; // Pointer to the previous node};// Function to insert a node at the beginning of the listvoid insertBeginning(Node*& head, int value) { // Create a new node Node* newNode = new Node; // Assign the value to the new node newNode->data = value; // Since it's the first node, the previous pointer is nullptr newNode->prev = nullptr; // If the list is empty, make the new node the head if (head == nullptr) { // Since it's the only node, the next pointer is nullptr newNode->next = nullptr; // Update the head pointer to point to the new node head = newNode; } else { // Point the new node's next pointer to the current head newNode->next = head; // Update the previous pointer of the current head to point to the new node head->prev = newNode; // Update the head pointer to point to the new node head = newNode; }}

#include <iostream>// Define the structure for a node in the doubly linked liststruct Node { int data; // Data stored in the node Node* next; // Pointer to the next node Node* prev; // Pointer to the previous node};// Function to insert a node at the end of the listvoid insertEnd(Node*& head, int value) { // Create a new node Node* newNode = new Node; // Assign the value to the new node newNode->data = value; // Initialize the next pointer to nullptr newNode->next = nullptr; // Check if the list is empty if (head == nullptr) { // If the list is empty, make the new node the head newNode->prev = nullptr; // Update the head pointer to point to the new node head = newNode; } else { // Start from the head of the list Node* current = head; // Traverse to the end of the list while (current->next != nullptr) { current = current->next; } // Adjust pointers to insert the new node at the end // Set the next pointer of the last node to point to // the new node current->next = newNode; // Set the previous pointer of the new node to point // to the last node newNode->prev = current; }}int main() { // Test the insertEnd function Node* head = nullptr; insertEnd(head, 1); insertEnd(head, 2); insertEnd(head, 3); // Print the list Node* current = head; while (current != nullptr) { std::cout << current->data << " "; current = current->next; } // Delete dynamically allocated memory while (head != nullptr) { Node* temp = head; head = head->next; delete temp; } return 0;}

// Define the structure for a node in the doubly linked listclass Node { int data; // Data stored in the node Node next; // Pointer to the next node Node prev; // Pointer to the previous node  // Constructor to initialize a node with data Node(int data) { this.data = data; this.next = null; this.prev = null; }}// Function to insert a node at the end of the listclass DoublyLinkedList { // Method to insert a node at the end of the list static Node insertEnd(Node head, int value) { // Create a new node Node newNode = new Node(value); // Check if the list is empty if (head == null) { // If the list is empty, make the new node the head head = newNode; } else { // Start from the head of the list Node current = head; // Traverse to the end of the list while (current.next != null) { current = current.next; } // Adjust pointers to insert the new node at the end // Set the next pointer of the last node to point to the new node current.next = newNode; // Set the previous pointer of the new node to point to the last node newNode.prev = current; } return head; }}// Test the insertEnd functionpublic class Main { public static void main(String[] args) { // Initialize an empty list Node head = null; // Insert nodes at the end of the list head = DoublyLinkedList.insertEnd(head, 1); head = DoublyLinkedList.insertEnd(head, 2); head = DoublyLinkedList.insertEnd(head, 3); // Print the list Node current = head; while (current != null) { System.out.println(current.data); current = current.next; } }}

# Define the structure for a node in the doubly linked listclass Node: def __init__(self, data): self.data = data # Data stored in the node self.next = None # Pointer to the next node self.prev = None # Pointer to the previous node# Function to insert a node at the end of the listdef insert_end(head, value): # Create a new node new_node = Node(value) # Check if the list is empty if head is None: # If the list is empty, make the new node the head head = new_node else: # Start from the head of the list current = head # Traverse to the end of the list while current.next is not None: current = current.next # Adjust pointers to insert the new node at the end # Set the next pointer of the last node to point to the new node current.next = new_node # Set the previous pointer of the new node to point to the last node new_node.prev = current return head# Test the insert_end functionhead = Nonehead = insert_end(head, 1)head = insert_end(head, 2)head = insert_end(head, 3)# Print the listcurrent = headwhile current is not None: print(current.data) current = current.next

// Define the structure for a node in the doubly linked listclass Node { constructor(data) { this.data = data; // Data stored in the node this.next = null; // Pointer to the next node this.prev = null; // Pointer to the previous node }}// Function to insert a node at the end of the listfunction insertEnd(head, value) { // Create a new node const newNode = new Node(value); // Check if the list is empty if (head === null) { // If the list is empty, make the new node the head head = newNode; } else { // Start from the head of the list let current = head; // Traverse to the end of the list while (current.next !== null) { current = current.next; } // Adjust pointers to insert the new node at the end // Set the next pointer of the last node to point to the new node current.next = newNode; // Set the previous pointer of the new node to point to the last node newNode.prev = current; } return head;}// Test the insertEnd functionlet head = null;head = insertEnd(head, 1);head = insertEnd(head, 2);head = insertEnd(head, 3);// Print the listlet current = head;while (current !== null) { console.log(current.data); current = current.next;}

#include <iostream>using namespace std;// Define the structure of a node in the doubly linked liststruct Node { int data; // Data stored in the node Node* prev; // Pointer to the previous node in the list Node* next; // Pointer to the next node in the list};// Function to insert a node at a specific position in the doubly linked listvoid insertAtPosition(Node** head, int position, int data) { // Create a new node and allocate memory Node* newNode = new Node(); // Set the data of the new node newNode->data = data; // Insert at the beginning of the list if (position == 0) { // New node points to the current head newNode->next = *head; // Previous of new node is null as it's the new head newNode->prev = nullptr; if (*head != nullptr) { // If list is not empty, set the previous of old head to new node (*head)->prev = newNode; } // Update the head to point to the new node *head = newNode; } else { // Pointer to traverse the list Node* current = *head; // Counter to track the position int count = 0; // Traverse to the node at position - 1 while (current != nullptr && count < position - 1) { current = current->next; // Move to the next node count++; // Increment position counter } // If reached end of list and position not found if (current == nullptr) { // Inform user about out of range position cout << "Position out of range" << endl; return; // Exit function } // Insert the new node between current and current->next newNode->next = current->next; // New node's next is set to current node's next newNode->prev = current; // New node's previous is set to current node if (current->next != nullptr) { // If there's a node after current, set its previous to new node current->next->prev = newNode; } // Set current node's next to the new node current->next = newNode; }}// Function to print the doubly linked listvoid printList(Node* head) { while (head != nullptr) { cout << head->data << " "; head = head->next; } cout << endl;}// Driver code to test the insertion functionint main() { // Create an empty list Node* head = nullptr; // Insert elements at various positions insertAtPosition(&head, 0, 10); // Insert 10 at position 0 insertAtPosition(&head, 1, 20); // Insert 20 at position 1 insertAtPosition(&head, 2, 30); // Insert 30 at position 2 // Print the list to verify the insertion printList(head); // Expected output: 10 20 30 return 0;}

// Node class represents each node in the doubly linked listclass Node { int data; Node prev; Node next; // Node constructor public Node(int data) { this.data = data; this.prev = null; this.next = null; }}// DoublyLinkedList class represents the entire listclass DoublyLinkedList { Node head; // DoublyLinkedList constructor public DoublyLinkedList() { this.head = null; } // Method to insert a node at a specific position public void insertAtPosition(int position, int data) { Node newNode = new Node(data); if (position == 0) { newNode.next = this.head; newNode.prev = null; if (this.head != null) { this.head.prev = newNode; } this.head = newNode; } else { Node current = this.head; int count = 0; while (current != null && count < position - 1) { current = current.next; count++; } if (current == null) { System.out.println("Position out of range"); return; } newNode.next = current.next; newNode.prev = current; if (current.next != null) { current.next.prev = newNode; } current.next = newNode; } }}// Main classpublic class Main { public static void main(String[] args) { // Create a doubly linked list DoublyLinkedList dll = new DoublyLinkedList(); // Insert nodes at specific positions dll.insertAtPosition(0, 10); dll.insertAtPosition(1, 20); dll.insertAtPosition(2, 30); // Print the list Node current = dll.head; while (current != null) { System.out.print(current.data + " "); current = current.next; } }}

class Node: def __init__(self, data=None): self.data = data self.prev = None self.next = Noneclass DoublyLinkedList: def __init__(self): self.head = None def insertAtPosition(self, position, data): newNode = Node(data) if position == 0: newNode.next = self.head newNode.prev = None if self.head is not None: self.head.prev = newNode self.head = newNode else: current = self.head count = 0 while current is not None and count < position - 1: current = current.next count += 1 if current is None: print("Position out of range") return newNode.next = current.next newNode.prev = current if current.next is not None: current.next.prev = newNode current.next = newNode# Create a doubly linked listdll = DoublyLinkedList()# Insert nodes at specific positionsdll.insertAtPosition(0, 10)dll.insertAtPosition(1, 20)dll.insertAtPosition(2, 30)# Print the listcurrent = dll.headwhile current: print(current.data,end=" ") current = current.next

// Define the structure of a node in the doubly linked listclass Node { constructor(data) { this.data = data; // Data stored in the node this.prev = null; // Pointer to the previous node in the list this.next = null; // Pointer to the next node in the list }}// Function to insert a node at a specific position in the doubly linked listfunction insertAtPosition(head, position, data) { // Create a new node const newNode = new Node(data); // Insert at the beginning of the list if (position === 0) { // New node points to the current head newNode.next = head; // Previous of new node is null as it's the new head newNode.prev = null; if (head !== null) { // If list is not empty, set the previous of old head to new node head.prev = newNode; } // Update the head to point to the new node return newNode; } let current = head; let count = 0; // Traverse to the node at position - 1 while (current !== null && count < position - 1) { current = current.next; count++; } // If reached end of list and position not found if (current === null) { console.log("Position out of range"); return head; // Return the original head unchanged } // Insert the new node between current and current.next newNode.next = current.next; newNode.prev = current; if (current.next !== null) { // If there's a node after current, set its previous to new node current.next.prev = newNode; } // Set current node's next to the new node current.next = newNode; return head;}// Function to print the doubly linked listfunction printList(head) { let current = head; while (current !== null) { console.log(current.data); current = current.next; }}// Driver code to test the insertion function(function main() { // Create an empty list let head = null; // Insert elements at various positions head = insertAtPosition(head, 0, 10); // Insert 10 at position 0 head = insertAtPosition(head, 1, 20); // Insert 20 at position 1 head = insertAtPosition(head, 2, 30); // Insert 30 at position 2 // Print the list to verify the insertion printList(head); // Expected output: 10 20 30})();// This code is contributed by Shivam Gupta

// Structure to represent a node in a doubly linked liststruct Node { int data; // Data stored in the node Node* next; // Pointer to the next node in the list Node* prev; // Pointer to the previous node in the list};// Function to delete the node at the beginning of a doubly// linked listvoid deleteAtBeginning(Node** head) { // Check if the list is empty if (*head == nullptr) { return; } // Check if the node to be deleted is the head node if (*head == (*head)->next) { // If the node to be deleted is the head node, // update the head pointer to point to the next node *head = (*head)->next; // If the list has only one node, set the head // pointer to NULL if (*head == nullptr) { return; } // Update the previous pointer of the new head node // to point to NULL (*head)->prev = nullptr;  // Delete the old head node delete *head; return; } // If the node to be deleted is not the head node, // update the previous pointer of the next node to point // to the previous node of the node to be deleted Node* temp = *head; *head = (*head)->next; (*head)->prev = nullptr; // Delete the node to be deleted delete temp;}

// Structure to represent a node in a doubly linked liststruct Node { int data; // Data stored in the node Node* next; // Pointer to the next node in the list Node* prev; // Pointer to the previous node in the list};void deleteAtEnd(Node*& head) { // Check if the list is empty if (head == nullptr) { return; } // Find the last node Node* curr = head; while (curr->next != nullptr) { curr = curr->next; } // Update the previous node's next pointer Node* prev = nullptr; while (prev->next != curr) { prev = prev->next; } prev->next = nullptr; // Delete the last node delete curr;}

class Node { int data; // Data stored in the node Node next; // Pointer to the next node in the list Node prev; // Pointer to the previous node in the list // Constructor to create a new node Node(int data) { this.data = data; this.next = null; this.prev = null; }}public class DoublyLinkedList { Node head; // Head of the list // Method to delete the node at the end public void deleteAtEnd() { // Check if the list is empty if (head == null) { return; } // Find the last node Node curr = head; while (curr.next != null) { curr = curr.next; } // Update the previous node's next pointer Node prev = curr.prev; if (prev != null) { prev.next = null; } else { // If the list only contains one node head = null; } // Delete the last node (handled by Java's garbage collector) }}

# Structure to represent a node in a doubly linked listclass Node: def __init__(self, data): self.data = data self.next = None self.prev = Nonedef delete_at_end(head): # Check if the list is empty if not head: return # Find the last node curr = head while curr.next: curr = curr.next # Find the node before the last node prev = head while prev.next != curr: prev = prev.next # Update the previous node's next pointer prev.next = None # Delete the last node del curr

class Node { constructor(data) { this.data = data; this.next = null; this.prev = null; }}function deleteAtEnd(head) { // Check if the list is empty if (head === null) { return; } // Find the last node let curr = head; while (curr.next !== null) { curr = curr.next; } // Update the previous node's next pointer let prev = null; let temp = head; while (temp.next !== curr) { prev = temp; temp = temp.next; } if (prev !== null) { prev.next = null; } else { head = null; // If there's only one node } // Delete the last node curr = null;}// This code is contributed by Rambabu

#include <iostream>struct Node { int data; Node* prev; Node* next;  Node(int val) : data(val), prev(nullptr), next(nullptr) {}};void deleteNodeAtPosition(Node* head, int position) { if (!head) { return; } Node* current = head; for (int i = 1; current && i < position; ++i) { current = current->next; } if (!current) { return; } if (current->prev) { current->prev->next = current->next; } if (current->next) { current->next->prev = current->prev; } if (head == current) { head = current->next; } delete current; // Deallocate memory for the deleted node (C++ specific)}

class Node { int data; // Data stored in the node Node prev; // Reference to the previous node in the doubly linked list Node next; // Reference to the next node in the doubly linked list}void deleteNodeAtPosition(Node head, int position) { // If the list is empty, there is nothing to delete if (head == null) { return; } Node current = head; // Traverse to the node at the specified position for (int i = 1; current != null && i < position; ++i) { current = current.next; } // If the specified position is beyond the end of the list, do nothing if (current == null) { return; } // Adjust references to skip the node to be deleted if (current.prev != null) { // Update the next reference of the previous node current.prev.next = current.next; } if (current.next != null) { // Update the prev reference of the next node current.next.prev = current.prev; } // Update head if the node to be deleted is the head if (head == current) { // Update the head reference if the first node is deleted head = current.next; } // Java's garbage collector will automatically deallocate memory for the deleted node}

class Node: def __init__(self, data=None): self.data = data # Data stored in the node self.prev = None # Reference to the previous node in the doubly linked list self.next = None # Reference to the next node in the doubly linked listdef deleteNodeAtPosition(head, position): # If the list is empty, there is nothing to delete if head is None: return current = head # Traverse to the node at the specified position for i in range(1, position): if current is None: return current = current.next # If the specified position is beyond the end of the list, do nothing if current is None: return # Adjust references to skip the node to be deleted if current.prev is not None: # Update the next reference of the previous node current.prev.next = current.next if current.next is not None: # Update the prev reference of the next node current.next.prev = current.prev # Update head if the node to be deleted is the head if head == current: # Update the head reference if the first node is deleted head = current.next # Python's garbage collector will automatically deallocate memory for the deleted node

class Node { constructor(data) { this.data = data; this.prev = null; this.next = null; }}function deleteNodeAtPosition(head, position) { if (!head) { return; } let current = head; for (let i = 1; current && i < position; ++i) { current = current.next; } if (!current) { return; } if (current.prev) { current.prev.next = current.next; } if (current.next) { current.next.prev = current.prev; } if (head === current) { head = current.next; }}