Delete from Beginning of Doubly Linked List in DSA Typescript - 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. This allows 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 pointer is set to null. The old first node is removed from the list.

beginner

Why do we set the new head's previous pointer to null after deletion?

Because the head node has no node before it, its previous pointer must be null to indicate the start of the list.

intermediate

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

Check if the list is empty (head is null). If empty, no deletion is possible. Also, if the list has only one node, after deletion the list becomes empty.

intermediate

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

if (!this.head) return; // empty list if (!this.head.next) { this.head = null; // only one node } else { this.head = this.head.next; this.head.prev = null; }

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

A Only the new head's next pointer

B Only the tail pointer

C The head pointer and the new head's previous pointer

D No pointers need updating

When deleting the first node, the head pointer moves to the second node, and the new head's previous pointer must be set to null.

What happens if you delete the first node in a list with only one node?

A The list becomes empty (head is null)

B The list still has one node

C The tail pointer moves to the next node

D The previous pointer of the node is set to null

Deleting the only node means the list becomes empty, so head is set to null.

If the list is empty, what should happen when trying to delete the first node?

A Nothing, because there is no node to delete

B Throw an error

C Create a new node

D Set head to a new node

If the list is empty (head is null), deletion does nothing because no nodes exist.

After deleting the first node, what should the previous pointer of the new head be?

A Point to the tail

B Point to the old head

C Point to itself

D Null

The new head has no previous node, so its previous pointer must be null.

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

A Move head to the next node

B Update tail pointer to new head

C Set old head's next pointer to null

D Set new head's previous pointer to null

The tail pointer does not change when deleting the first node unless the list had only one node.

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

Think about what happens to the head and the pointers around it.

Describe the edge cases to consider when deleting the first node in a doubly linked list.

Consider list size and pointer updates.

Practice

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

easy

A. It moves to the previous node

B. It becomes null immediately

C. It stays pointing to the deleted node

D. It moves to the next node in the list

Solution

1. Step 1: Understand the role of head pointer

   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, head must point to the next node to keep the list accessible.

3. Final Answer:

   It moves to the next node in the list -> Option D

4. Quick Check:

   head points to next node after deletion [OK]

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

Common Mistakes:

• Setting head to null without checking if list is empty
• Not updating head after deletion
• Pointing head to deleted node

2. Which of the following is the correct TypeScript syntax to delete the first node from a doubly linked list assuming head is the pointer to the first node?

easy

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

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

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

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

Solution

1. Step 1: Move head to next node

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

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

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

3. Final Answer:

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

4. Quick Check:

   Correct syntax to update head and prev pointer [OK]

Hint: Update head first, then fix prev pointer [OK]

Common Mistakes:

• Setting head.prev before moving head
• Assigning head.prev to null before head changes
• Setting head.next to null incorrectly

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

medium

A. 20 <-> 30 <-> null

B. 10 <-> 30 <-> null

C. 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 next node

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

3. Final Answer:

   20 <-> 30 <-> null -> Option A

4. Quick Check:

   First node removed, list starts at 20 [OK]

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

Common Mistakes:

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

4. Consider this TypeScript code snippet to delete the first node from a doubly linked list:

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

What error can occur here?

medium

A. Logical error: head.prev should not be set to null

B. Syntax error due to missing semicolon

C. Runtime error if list has only one node

D. No error, code is correct

Solution

1. Step 1: Check condition when list has one node

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

2. Step 2: Accessing head.prev causes error

   head becomes null, so head.prev causes runtime error (cannot access property of null).

3. Final Answer:

   Runtime error if list has only one node -> Option C

4. Quick Check:

   Null pointer access error possible [OK]

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

Common Mistakes:

• Not checking if head is null after moving to next
• Assuming list always has multiple nodes
• Ignoring runtime null errors

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> 35 <-> null. Write the correct sequence of operations to delete the first node safely, considering the list might have only one node.

hard

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

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

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

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

Solution

1. Step 1: Check if list is empty

   First, verify head is not null to avoid errors on empty list.

2. Step 2: Move head to next node and check again

   After moving head, check if new head is not null before setting prev to null.

3. Final Answer:

   if (head !== null) { head = head.next; if (head !== null) head.prev = null; } -> Option B

4. Quick Check:

   Safe deletion with null checks [OK]

Hint: Always check for null before accessing pointers [OK]

Common Mistakes:

• Not checking if head is null after moving
• Setting prev pointer without null check
• Assuming list has multiple nodes always