Delete from End of Doubly Linked List in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to move to the last node in the doubly linked list.

DSA Javascript

while (current.next [1] null) {
  current = current.next;
}

Drag options to blanks, or click blank then click option'

A>

B!==

C=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of !== causes the loop to stop immediately.

Using = assigns instead of compares, causing errors.

We use !== null to continue moving until the next node is null, which means current is the last node.

2fill in blank

medium

Complete the code to update the previous node's next pointer when deleting the last node.

DSA Javascript

if (current.prev) {
  current.prev.[1] = null;
}

Drag options to blanks, or click blank then click option'

Avalue

Bprev

Cnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev instead of next breaks the list links.

Setting value or head does not affect the node connections.

We set the previous node's next pointer to null to remove the last node from the list.

3fill in blank

hard

Fix the error in updating the head when the list has only one node.

DSA Javascript

if (!current.prev) {
  [1] = null;
}

Drag options to blanks, or click blank then click option'

Ahead

Btail

Ccurrent

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Setting current or tail to null does not update the list head.

Setting prev to null does not remove the node from the list.

If the current node has no previous node, it means it's the head, so we set head to null after deletion.

4fill in blank

hard

Fill both blanks to correctly delete the last node and update the tail pointer.

DSA Javascript

if (current.prev) {
  current.prev.[1] = null;
  [2] = current.prev;
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Ctail

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next breaks the link.

Updating head instead of tail causes incorrect list end.

We set the previous node's next to null and update tail to point to the previous node after deletion.

5fill in blank

hard

Fill all three blanks to complete the delete from end function for a doubly linked list.

DSA Javascript

function deleteFromEnd() {
  if (!head) return null;
  let current = head;
  while (current.next [1] null) {
    current = current.next;
  }
  if (current.prev) {
    current.prev.[2] = null;
    [3] = current.prev;
  } else {
    head = null;
    tail = null;
  }
}

Drag options to blanks, or click blank then click option'

A!==

Bnext

Ctail

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of !== causes incorrect loop behavior.

Setting prev instead of next breaks the list.

Not updating tail causes tail to point to deleted node.

We loop while current.next !== null to reach the last node, set current.prev.next to null to remove it, and update tail to current.prev.

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