Delete from Beginning 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 list where each node has two links: one to the next node and one to the previous node, allowing traversal in both directions.

beginner

What happens when you delete the first node in a doubly linked list?

The head pointer moves to the second node, and the new head's previous link is set to null, removing the first node from the list.

intermediate

Why do we need to update the 'prev' pointer of the new head node when deleting from the beginning?

Because the new head node no longer has a node before it, its 'prev' pointer must be set to null to correctly represent the start of the list.

beginner

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

You should check if the list is empty first and handle it gracefully, usually by doing nothing or returning null, since there is no node to delete.

intermediate

Show the JavaScript code snippet to delete the first node from a doubly linked list.

function deleteFromBeginning() {
  if (!this.head) return null;
  const deletedNode = this.head;
  this.head = this.head.next;
  if (this.head) this.head.prev = null;
  return deletedNode;
}

What pointer must be updated when deleting the first node in a doubly linked list?

A The 'prev' pointer of the last node

B The 'next' pointer of the last node

C The 'next' pointer of the deleted node

D The 'prev' pointer of the new head node

When deleting the first node, the new head's 'prev' pointer must be set to null to indicate it has no previous node.

If the doubly linked list has only one node, what happens after deleting from the beginning?

A The list becomes empty (head is null)

B The head points to itself

C The list remains unchanged

D The tail pointer is updated but head remains

Deleting the only node makes the list empty, so the head pointer becomes null.

Which of these is NOT a step when deleting the first node in a doubly linked list?

A Set new head's prev to null

B Update tail pointer to new head

C Set deleted node's next to null

D Move head to the next node

The tail pointer does not need to be updated unless the list becomes empty.

What should your delete function return after deleting the first node?

A The deleted node

B The new head node

C The tail node

D Null always

Returning the deleted node helps confirm what was removed or for further use.

What is the time complexity of deleting the first node in a doubly linked list?

A O(log n)

B O(n)

C O(1)

D O(n^2)

Deleting the first node is a constant time operation because it involves only a few pointer updates.

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

Think about what happens to the head and the previous pointer.

Write a simple JavaScript function to delete the first node from a doubly linked list and return the deleted node.

Focus on pointer updates and edge cases.

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