w3resource

JavaScript Exercises: Remove the tail element from a doubly Linked lists

JavaScript Data Structures: Exercise-16 with Solution

Remove the tail element from a DLL

Write a JavaScript program that removes the tail element from a doubly Linked lists.

Sample Solution:

JavaScript Code:

class Node {
         // Constructor function for creating a new node with a given value
         constructor(value) {
                  this.value = value; // Assign the given value to the node
                  this.next = null; // Initialize the pointer to the next node as null
                  this.previous = null; // Initialize the pointer to the previous node as null
         }
}
class DoublyLinkedList {
         // Constructor function for creating a new doubly linked list with a head node having the given value
         constructor(value) {
                  // Initialize the head node with the given value and no next or previous node
                  this.head = {
                            value: value, // Store the value of the head node
                            next: null, // Pointer to the next node in the list, initially set to null
                            previous: null // Pointer to the previous node in the list, initially set to null
                  };
                  this.length = 0; // Initialize the length of the list to 0
                  this.tail = this.head; // Set the tail node to the head node initially
         }
 add(newNode) {
   if (this.head === null) { // If the list is empty
   this.head = newNode; // Set the new node as both head and tail
   this.tail = newNode;
   }
   else
   {
   newNode.previous = this.tail; // Set the previous pointer of the new node to the current tail node
   this.tail.next = newNode; // Set the next pointer of the current tail node to the new node
   this.tail = newNode; // Update the tail node to the new node
   }
    this.length++; // Increment the length of the list
  }
 remove_Tail() {
   if (!this.tail) { // If the list is empty, return null
     return null;
   }
   if (!this.tail.previous) { // If there is only one node in the list
     this.tail = null; // Set tail to null
     this.head = null; // Also set head to null
     return;
   }
   this.tail = this.tail.previous; // Update the tail to the previous node
   this.tail.next = null; // Set the next pointer of the new tail to null
   this.length--; // Decrement the length of the list
 }
 printList(){
                  let current = this.head; // Start from the head of the list
                  let result = []; // Array to store the values of the nodes
                  while (current !== null) { // Iterate through the list until reaching the end
                            result.push(current.value); // Push the value of the current node to the array
                            current = current.next; // Move to the next node
                  }
                  console.log(result.join(' ')); // Log the values of the nodes separated by space
                  return this; // Return the DoublyLinkedList object for chaining
          }
}
let numList = new DoublyLinkedList(); // Create a new instance of the DoublyLinkedList class
numList.add(new Node(2)); // Add nodes to the list
numList.add(new Node(3));
numList.add(new Node(4));
numList.add(new Node(5));
numList.add(new Node(6));
numList.add(new Node(7));
console.log("Original Doubly Linked Lists:"); // Print the original list
numList.printList();
console.log("Remove the Tail element:"); // Remove the tail element
numList.remove_Tail();
numList.printList();
console.log("Remove the Tail element:"); // Remove the tail element again
numList.remove_Tail();
numList.printList();

Output:

Original Doubly Linked Lists:
 2 3 4 5 6 7
Remove the Tail element:
 2 3 4 5 6
Remove the Tail element:
 2 3 4 5

Flowchart:

Flowchart: JavaScript Exercises: Remove the tail element from a doubly Linked lists.
Flowchart: JavaScript Exercises: Remove the tail element from a doubly Linked lists.

Live Demo:

See the Pen javascript-doubly-linked-list-exercise-16 by w3resource (@w3resource) on CodePen.


For more Practice: Solve these Related Problems:

  • Write a JavaScript function that removes the tail node from a doubly linked list and updates the tail pointer accordingly.
  • Write a JavaScript function that traverses backward from the tail to remove the last node and maintain list integrity.
  • Write a JavaScript function that handles edge cases when the DLL contains only one node during tail removal.
  • Write a JavaScript function that removes the tail element and returns the updated doubly linked list structure.

Go to:


PREV : Remove the head element from a DLL.
NEXT : Update the value of a node at a specific index in a DLL.

Improve this sample solution and post your code through Disqus

What is the difficulty level of this exercise?

Test your Programming skills with w3resource's quiz.



Follow us on Facebook and Twitter for latest update.