Delete from End of Doubly Linked List in DSA Javascript - Build from Scratch

Delete from End of Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each song is a node with a title, and links to the previous and next songs. You want to remove the last song from the playlist.

🎯 Goal: Build a doubly linked list with 3 songs, then delete the last song from the list, and finally print the playlist from start to end.

📋 What You'll Learn

Create a doubly linked list with nodes containing title values: 'Song A', 'Song B', 'Song C'

Create a variable head pointing to the first node

Create a variable tail pointing to the last node

Delete the last node from the doubly linked list by updating tail and links

Print the playlist titles from head to null in the format: Song A -> Song B -> null

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to manage sequences where you can move forward and backward easily.

💼 Career

Understanding linked lists and how to manipulate them is a key skill for software developers working with data structures and memory management.

1

Create the Doubly Linked List with 3 Songs

Create three nodes called node1, node2, and node3 representing songs with titles 'Song A', 'Song B', and 'Song C'. Link them as a doubly linked list by setting their next and prev properties. Finally, create variables head and tail pointing to node1 and node3 respectively.

DSA Javascript

// Create nodes node1, node2, node3 with titles and link them
// Set head and tail variables
// Your code here

Hint

Each node is an object with title, prev, and next. Link them by setting next and prev accordingly.

2

Create a Variable to Track the Current Tail

Create a variable called currentTail and set it equal to the existing tail variable.

DSA Javascript

const node1 = { title: 'Song A', prev: null, next: null };
const node2 = { title: 'Song B', prev: null, next: null };
const node3 = { title: 'Song C', prev: null, next: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

const head = node1;
const tail = node3;

// Create currentTail variable equal to tail
// Your code here

Hint

Just assign currentTail to the existing tail variable.

3

Delete the Last Node from the Doubly Linked List

Delete the last node by updating tail to currentTail.prev. Then set tail.next to null to remove the link to the deleted node.

DSA Javascript

const node1 = { title: 'Song A', prev: null, next: null };
const node2 = { title: 'Song B', prev: null, next: null };
const node3 = { title: 'Song C', prev: null, next: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

const head = node1;
const tail = node3;

const currentTail = tail;

// Update tail to currentTail.prev
// Set tail.next to null
// Your code here

Hint

Set tail to the previous node of currentTail. Then remove the link forward by setting tail.next to null.

4

Print the Playlist from Head to End

Use a while loop with a variable current starting at head. Print the title of each node followed by ->. Stop when current is null. Finally, print null to show the end of the list.

DSA Javascript

const node1 = { title: 'Song A', prev: null, next: null };
const node2 = { title: 'Song B', prev: null, next: null };
const node3 = { title: 'Song C', prev: null, next: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

const head = node1;
let tail = node3;

const currentTail = tail;

tail = currentTail.prev;
tail.next = null;

// Print the playlist titles from head to null
// Your code here

Hint

Use a loop to move from head through each node's next. Build a string with titles and arrows, then print it.

Practice

1. What happens to the tail pointer when you delete the last node from a doubly linked list?

easy

A. It moves to the next node of the deleted node.

B. It becomes null immediately without change.

C. It moves to the previous node of the deleted node.

D. It stays pointing to the deleted node.

Solution

1. Step 1: Understand tail pointer role

   The tail pointer always points to the last node in the list.

2. Step 2: Effect of deleting last node

   When the last node is deleted, tail must move to the previous node to remain correct.

3. Final Answer:

   It moves to the previous node of the deleted node. -> Option C

4. Quick Check:

   Tail updates to previous node [OK]

Hint: Tail always points to last node, update to previous on delete [OK]

Common Mistakes:

• Setting tail to null without checking list emptiness
• Not updating tail pointer after deletion
• Moving tail to next node which doesn't exist

2. Which of the following is the correct syntax to remove the last node from a doubly linked list in JavaScript?

easy

A. tail = tail.prev; tail.next = null;

B. tail = tail.next; tail.prev = null;

C. tail = tail.prev; tail.prev = null;

D. tail = null; head = null;

Solution

1. Step 1: Move tail pointer to previous node

   To delete last node, tail moves to tail.prev.

2. Step 2: Set new tail's next to null

   New tail's next must be null to mark end of list.

3. Final Answer:

   tail = tail.prev; tail.next = null; -> Option A

4. Quick Check:

   Correct tail update and next nullify [OK]

Hint: Tail moves back, next pointer cleared [OK]

Common Mistakes:

• Moving tail forward instead of backward
• Not setting tail.next to null
• Setting tail.prev to null incorrectly

3. Consider the following doubly linked list: 1 <-> 2 <-> 3 <-> 4. After deleting the last node, what will be the new list?

medium

A. 2 <-> 3 <-> 4

B. 1 <-> 2 <-> 3

C. 1 <-> 2 <-> 3 <-> 4

D. 1 <-> 2

Solution

1. Step 1: Identify last node

   Last node is 4, which will be removed.

2. Step 2: Remove last node and update tail

   Tail moves to node 3, and node 3's next becomes null.

3. Final Answer:

   1 <-> 2 <-> 3 -> Option B

4. Quick Check:

   Last node removed, list ends at 3 [OK]

Hint: Remove last node, tail moves back [OK]

Common Mistakes:

• Forgetting to update tail pointer
• Not setting new tail's next to null
• Removing wrong node

4. Given this code snippet to delete the last node from a doubly linked list, what is the error?

if (tail === null) return;
tail = tail.prev;
tail.next = null;

medium

A. It should check if tail.next is null before deleting.

B. It incorrectly sets tail.next to null before moving tail.

C. It should set tail.prev to null instead of tail.next.

D. It does not handle the case when list has only one node.

Solution

1. Step 1: Check single node case

   If list has one node, tail.prev is null, so tail becomes null.

2. Step 2: Problem with tail.next assignment

   After tail becomes null, tail.next causes error because tail is null.

3. Final Answer:

   It does not handle the case when list has only one node. -> Option D

4. Quick Check:

   Single node deletion needs special handling [OK]

Hint: Check single node before updating tail [OK]

Common Mistakes:

• Not checking if tail is null after update
• Accessing properties of null tail
• Ignoring empty list case

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30. After deleting the last node twice, what will be the state of the list?

hard

A. 10

B. 10 <-> 20

C. 20

D. Empty list

Solution

1. Step 1: Delete last node once

   Last node 30 is removed, list becomes 10 <-> 20.

2. Step 2: Delete last node again

   Now last node 20 is removed, list becomes 10 only.

3. Step 3: Verify final list

   After two deletions, list is just node 10.

4. Final Answer:

   10 -> Option A

5. Quick Check:

   Two deletions remove last two nodes [OK]

Hint: Delete last node repeatedly removes tail nodes [OK]

Common Mistakes:

• Assuming list becomes empty after two deletions
• Not updating tail pointer correctly
• Confusing node values after deletion