Delete Node at Beginning in DSA Typescript

Mental Model

Removing the first item means moving the start pointer to the next item, skipping the old first.

Analogy: Imagine a line of people holding hands. To remove the first person, the second person becomes the new front of the line.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, delete node at beginning

Goal: Remove the first node and update the head to the next node

Step 1: store current head (node 1) to remove

head -> [1] -> 2 -> 3 -> null

Why: We keep a reference to the node to delete it safely

Step 2: move head pointer to next node (node 2)

head -> 2 -> 3 -> null

Why: The second node becomes the new first node

Step 3: remove old first node (node 1) by disconnecting it

head -> 2 -> 3 -> null

Why: Old first node is no longer linked and can be cleaned up

Result:

head -> 2 -> 3 -> null

Annotated Code

DSA Typescript

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

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

  insertAtEnd(value: number): void {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  deleteAtBeginning(): void {
    if (!this.head) return; // empty list, nothing to delete
    const toDelete = this.head; // store current head
    this.head = this.head.next; // move head to next node
    toDelete.next = null; // disconnect old head
  }

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

// Driver code
const list = new LinkedList();
list.insertAtEnd(1);
list.insertAtEnd(2);
list.insertAtEnd(3);
console.log('Original list:');
list.printList();

list.deleteAtBeginning();
console.log('After deleting at beginning:');
list.printList();

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

check if list is empty to avoid errors

const toDelete = this.head; // store current head

keep reference to node to remove

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

advance head pointer to second node

toDelete.next = null; // disconnect old head

disconnect old first node to help garbage collection

Output

Original list:

1 -> 2 -> 3 -> null

After deleting at beginning:

2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change the head pointer without traversing the list

Space: O(1) because no extra space is used except a temporary pointer

vs Alternative: Compared to deleting at the end which requires O(n) traversal, deleting at 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

head becomes null, list becomes empty

DSA Typescript

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

When to Use This Pattern

When you need to remove the first element quickly from a list, use delete at beginning because it only changes the head pointer.

Common Mistakes

Mistake: Not updating the head pointer and trying to remove the node by traversing
Fix: Directly move the head pointer to the next node to remove the first node

Summary

Deletes the first node by moving the head pointer to the next node.

Use when you want to remove the front item of a linked list efficiently.

The key is to update the head pointer to skip the old first node.

Practice

1. What happens when you delete the first node in a singly linked list?

easy

A. The head pointer moves to the second node

B. The last node is deleted

C. The list becomes empty immediately

D. The middle node is removed

Solution

1. Step 1: Understand the head pointer role

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

2. Step 2: Delete the first node by moving head

   Deleting the first node means moving the head pointer to the next node.

3. Final Answer:

   The head pointer moves to the second node -> Option A

4. Quick Check:

   Delete first node = move head to next [OK]

Hint: Deleting first node means moving head to next node [OK]

Common Mistakes:

• Thinking the last node is deleted
• Assuming list becomes empty always
• Deleting a middle node instead

2. Which of the following is the correct TypeScript syntax to delete the first node in a singly linked list with head pointer head?

easy

A. head = head.next;

B. head.next = head;

C. delete head;

D. head = null.next;

Solution

1. Step 1: Understand head and next pointers

   head points to first node; head.next points to second node.

2. Step 2: Assign head to head.next to delete first node

   Setting head = head.next moves head to second node, effectively deleting first.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   Correct syntax to delete first node = head = head.next; [OK]

Hint: Use head = head.next to delete first node [OK]

Common Mistakes:

• Using delete keyword incorrectly
• Assigning head.next to head
• Accessing null.next causing error

3. Given the linked list: 1 -> 2 -> 3 -> null and the code snippet:

head = head.next;

What is the resulting linked list?

medium

A. 1 -> 2 -> 3 -> null

B. 2 -> 3 -> null

C. 3 -> null

D. null

Solution

1. Step 1: Initial list and head pointer

   Head points to node with value 1, list is 1 -> 2 -> 3 -> null.

2. Step 2: Move head to head.next

   head = head.next moves head to node with value 2, removing first node.

3. Final Answer:

   2 -> 3 -> null -> Option B

4. Quick Check:

   After deletion, list starts at 2 [OK]

Hint: After head = head.next, list starts from second node [OK]

Common Mistakes:

• Assuming list remains unchanged
• Thinking last node is deleted
• Confusing node values after deletion

4. Consider this TypeScript code to delete the first node:

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

What error does this fix compared to just head = head.next;?

medium

A. Prevents deleting the last node

B. Prevents memory leak

C. Prevents runtime error if list is empty

D. Prevents deleting middle node

Solution

1. Step 1: Understand head could be null

   If list is empty, head is null and head.next causes error.

2. Step 2: Check head before accessing next

   Condition ensures head is not null before moving to head.next, avoiding runtime error.

3. Final Answer:

   Prevents runtime error if list is empty -> Option C

4. Quick Check:

   Check head != null before head.next avoids error [OK]

Hint: Check head not null before deleting first node [OK]

Common Mistakes:

• Ignoring null head causing crash
• Thinking it prevents memory leaks
• Confusing node positions deleted

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40 -> null. You want to delete the first two nodes safely. Which code snippet correctly does this?

hard

A. head = null;

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

C. head.next = head.next.next;

D. if (head && head.next) { head = head.next.next; }

Solution

1. Step 1: Understand deleting two nodes means moving head twice

   Deleting first two nodes means head should point to third node.

2. Step 2: Check head and head.next exist before moving head twice

   Condition ensures no runtime error when accessing head.next.next.

3. Final Answer:

   if (head && head.next) { head = head.next.next; } -> Option D

4. Quick Check:

   Check head and head.next before double move [OK]

Hint: Check head and head.next before skipping two nodes [OK]

Common Mistakes:

• Not checking head.next causing error
• Assigning head.next instead of head
• Setting head to null deletes entire list