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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to update the head pointer when deleting the first node.

DSA Javascript

this.head = this.head[1];

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

A.next

B.data

C.prev

D.tail

Attempts:

3 left

💡 Hint

Common Mistakes

Using .prev instead of .next causes the head to point backward.

Using .data instead of a node reference breaks the list structure.

When deleting the first node, the head should point to the next node in the list.

2fill in blank

medium

Complete the code to set the previous pointer of the new head to null after deletion.

DSA Javascript

if (this.head) this.head[1] = null;

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

A.prev

B.data

C.tail

D.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting .next to null disconnects the list incorrectly.

Forgetting to check if head exists before setting .prev causes errors.

After deleting the first node, the new head's previous pointer should be null.

3fill in blank

hard

Fix the error in the code that handles the case when the list becomes empty after deletion.

DSA Javascript

if (!this.head) this.[1] = null;

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

Ahead

Btail

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Setting head to null again is redundant here.

Setting next or prev to null does not update the list pointers correctly.

When the list is empty, both head and tail should be null. Here, tail is set to null.

4fill in blank

hard

Fill both blanks to complete the deleteFromBeginning method that removes the first node.

DSA Javascript

deleteFromBeginning() {
  if (!this.head) return null;
  const removed = this.head;
  this.head = this.head[1];
  if (this.head) this.head[2] = null;
  else this.tail = null;
  return removed.data;
}

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

A.next

B.prev

C.data

D.tail

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping .next and .prev causes incorrect pointer updates.

Not setting tail to null when list becomes empty.

The head moves to the next node, and the new head's previous pointer is set to null.

5fill in blank

hard

Fill all three blanks to complete the full deleteFromBeginning method with proper pointer updates and return value.

DSA Javascript

deleteFromBeginning() {
  if (!this.head) return null;
  const removed = this.head;
  this.head = this.head[1];
  if (this.head) this.head[2] = null;
  else this.[3] = null;
  return removed.data;
}

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

A.next

B.prev

Ctail

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Setting head to null instead of tail in the else block.

Forgetting to return removed.data.

The head moves to next, new head's prev is null, and tail is set to null if list is empty.

Practice

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

easy

A. It remains unchanged

B. It moves to the second node in the list

C. It points to the last node

D. It becomes null immediately

Solution

1. Step 1: Understand the head pointer role

   The head pointer always points to the first node in the list.

2. Step 2: Effect of deleting the first node

   When the first node is deleted, the head pointer must move to the next node, which becomes the new first node.

3. Final Answer:

   It moves to the second node in the list -> Option B

4. Quick Check:

   Head points to new first node after deletion [OK]

Hint: Head always points to the first node after deletion [OK]

Common Mistakes:

• Assuming head becomes null without checking list length
• Not updating head pointer after deletion
• Pointing head to last node mistakenly

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

easy

A. head.prev = null; head = head.next;

B. head = null; head.next = null;

C. head.next = null; head = head.prev;

D. head = head.next; head.prev = null;

Solution

1. Step 1: Move head to next node

   Assign head to head.next to remove the first node reference.

2. Step 2: Update new head's prev pointer

   Set head.prev to null to disconnect backward link from old first node.

3. Final Answer:

   head = head.next; head.prev = null; -> Option D

4. Quick Check:

   Correct syntax updates head and prev pointer [OK]

Hint: Update head first, then set new head.prev to null [OK]

Common Mistakes:

• Setting head.prev before moving head
• Setting head.next to null incorrectly
• Nullifying head before updating pointers

3. Consider the doubly linked list: 10 <-> 20 <-> 30 <-> null. After deleting the first node, what will be the new list?

medium

A. 30 <-> null

B. 10 <-> 30 <-> null

C. 20 <-> 30 <-> null

D. null

Solution

1. Step 1: Identify the first node

   The first node is 10, which will be removed.

2. Step 2: Update head to second node

   Head moves to 20, and 20.prev is set to null.

3. Final Answer:

   20 <-> 30 <-> null -> Option C

4. Quick Check:

   First node removed, list starts at 20 [OK]

Hint: After deletion, list starts from second node [OK]

Common Mistakes:

• Leaving old head in list
• Not updating prev pointer of new head
• Removing wrong node

4. Given this code snippet to delete the first node, what is the error?

if (head !== null) {
  head = head.next;
  head.prev = null;
}

medium

A. head.prev assignment causes error if list has one node

B. No error, code works fine

C. head.next should be assigned to null before head update

D. head should be set to null before updating prev

Solution

1. Step 1: Check list with one node

   If list has one node, head.next is null after head = head.next.

2. Step 2: Accessing head.prev causes error

   head is now null, so head.prev causes runtime error (cannot read property 'prev' of null).

3. Final Answer:

   head.prev assignment causes error if list has one node -> Option A

4. Quick Check:

   Null head causes error on prev access [OK]

Hint: Check if head is null before accessing head.prev [OK]

Common Mistakes:

• Not handling single-node list case
• Accessing properties of null head
• Assuming list always has multiple nodes

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> 35 <-> null. Write a function to delete the first node and return the updated list head. What will be the list after deletion?

hard

A. 15 <-> 25 <-> 35 <-> null

B. 5 <-> 25 <-> 35 <-> null

C. 25 <-> 35 <-> null

D. null

Solution

1. Step 1: Move head to next node

   Head moves from 5 to 15, the second node.

2. Step 2: Set new head's prev to null

   Set 15.prev = null to disconnect from old first node.

3. Step 3: Return updated head

   Return the new head pointing to 15.

4. Final Answer:

   15 <-> 25 <-> 35 <-> null -> Option A

5. Quick Check:

   First node removed, list starts at 15 [OK]

Hint: Update head and set new head.prev to null [OK]

Common Mistakes:

• Not updating prev pointer of new head
• Returning old head instead of new head
• Deleting wrong node or skipping nodes