Delete from End of Doubly Linked List in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a doubly linked list?

A doubly linked list is a chain of nodes where each node has three parts: data, a pointer to the next node, and a pointer to the previous node. It allows moving forward and backward through the list.

beginner

What happens when you delete the last node from a doubly linked list?

The last node is removed, the previous node's next pointer is set to null, and the list's tail pointer is updated to the previous node.

beginner

Why do we need to update the tail pointer when deleting from the end?

Because the tail pointer always points to the last node. After deletion, the last node changes, so the tail pointer must point to the new last node.

intermediate

What should you check before deleting the last node in a doubly linked list?

Check if the list is empty (no nodes) or has only one node. If only one node, deleting it makes the list empty, so head and tail become null.

intermediate

In JavaScript, how do you remove the last node from a doubly linked list?

You update the tail to point to tail.prev, set tail.next to null, and if the list becomes empty, set head and tail to null.

What pointer do you update when deleting the last node in a doubly linked list?

A Next pointer of head

B Head pointer

C Tail pointer

D Previous pointer of head

The tail pointer must be updated to the previous node because the last node is removed.

If a doubly linked list has only one node and you delete from the end, what happens?

A List becomes empty, head and tail set to null

B Tail points to the same node

C Head points to null but tail remains

D Nothing changes

Deleting the only node empties the list, so both head and tail become null.

What is the time complexity of deleting the last node in a doubly linked list if tail pointer is known?

A O(n^2)

B O(1)

C O(log n)

D O(n)

With direct access to tail, deletion from end is constant time.

Which pointer of the new last node must be updated after deleting the last node?

A Next pointer to null

B Previous pointer to null

C Next pointer to head

D Previous pointer to tail

The new last node's next pointer must be set to null to mark the end.

What should you do if the doubly linked list is empty and you try to delete from the end?

A Set head and tail to a new node

B Throw an error

C Create a new node

D Do nothing or return null

If the list is empty, deletion does nothing or returns null safely.

Explain step-by-step how to delete the last node from a doubly linked list.

Think about the pointers and edge cases.

Describe how the doubly linked list changes visually after deleting the last node.

Imagine walking backward through the list.

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