Delete from Beginning of Doubly Linked List in DSA Typescript

Mental Model

Removing the first item means moving the start pointer to the next item and fixing links so the list stays connected.

Analogy: Imagine a train where you remove the first carriage and then connect the engine directly to the second carriage so the train stays whole.

null ← 1 ↔ 2 ↔ 3 -> null
↑head

Dry Run Walkthrough

Input: list: 1 ↔ 2 ↔ 3, delete from beginning

Goal: Remove the first node and update the list so it starts from the second node

Step 1: Identify the current head node (1) to remove

null ← [1] ↔ 2 ↔ 3 -> null
↑head

Why: We need to remove the first node, so we start at the head

Step 2: Move head pointer to the next node (2)

null ← 1 ↔ [2] ↔ 3 -> null
↑head

Why: The new head should be the second node after removal

Step 3: Set new head's previous pointer to null to detach old head

null ← [2] ↔ 3 -> null
↑head

Why: Removing backward link to old head keeps list consistent

Result:

null ← 2 ↔ 3 -> null
↑head

Annotated Code

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  prev: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}

class DoublyLinkedList {
  head: Node | null;
  tail: Node | null;
  constructor() {
    this.head = null;
    this.tail = null;
  }

  append(value: number): void {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
      return;
    }
    this.tail!.next = newNode;
    newNode.prev = this.tail;
    this.tail = newNode;
  }

  deleteFromBeginning(): void {
    if (!this.head) return; // empty list, nothing to delete
    if (!this.head.next) {
      this.head = null; // single node list becomes empty
      this.tail = null;
      return;
    }
    this.head = this.head.next; // move head to next node
    this.head.prev = null; // detach old head backward link
  }

  printList(): void {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' ↔ ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const dll = new DoublyLinkedList();
dll.append(1);
dll.append(2);
dll.append(3);
console.log('Original list:');
dll.printList();
dll.deleteFromBeginning();
console.log('After deleting from beginning:');
dll.printList();

if (!this.head) return; // empty list, nothing to delete

check if list is empty, no deletion needed

if (!this.head.next) { this.head = null; this.tail = null; return; }

handle single node list by clearing head and tail

this.head = this.head.next; // move head to next node

advance head pointer to second node

this.head.prev = null; // detach old head backward link

remove backward link to old head to maintain list integrity

Output

Original list:

1 ↔ 2 ↔ 3 ↔ null

After deleting from beginning:

2 ↔ 3 ↔ null

Complexity Analysis

Time: O(1) because we only update a few pointers without traversing the list

Space: O(1) since no extra space is used besides a few pointers

vs Alternative: Compared to deleting from the middle which requires traversal O(n), deleting from beginning is faster and simpler

Edge Cases

empty list

no deletion occurs, list remains empty

DSA Typescript

if (!this.head) return; // empty list, nothing to delete

single node list

list becomes empty after deletion

DSA Typescript

if (!this.head.next) {
  this.head = null;
  this.tail = null;
  return;
}

When to Use This Pattern

When you need to remove the first element of a doubly linked list quickly, use this pattern to update head and fix links in constant time.

Common Mistakes

Mistake: Not setting the new head's prev pointer to null after deletion
Fix: Always set this.head.prev = null after moving head to next node

Mistake: Not handling the empty or single node list cases
Fix: Add checks for empty list and single node list before deletion

Summary

Deletes the first node of a doubly linked list and updates pointers accordingly.

Use when you want to remove the front element efficiently from a doubly linked list.

The key is to move the head pointer forward and remove backward links to the old head.

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