Insert at Beginning Head Insert in DSA Typescript

Mental Model

Add a new item right at the start so it becomes the first thing in the list.

Analogy: Imagine putting a new book on the front of a line of books on a shelf, pushing the others back.

null
head -> null

Dry Run Walkthrough

Input: list: 2 -> 3 -> null, insert value 1 at beginning

Goal: Add the new value 1 so it becomes the first node in the list

Step 1: Create new node with value 1

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

Why: We need a new node to insert at the start

Step 2: Set new node's next to current head (node 2)

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

Why: Link new node to the existing list so it points to the old first node

Step 3: Update head to new node (1)

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

Why: Make new node the first node in the list

Result:

head -> 1 -> 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;
  }

  insertAtBeginning(value: number): void {
    const newNode = new Node(value); // create new node
    newNode.next = this.head; // link new node to current head
    this.head = newNode; // update head to new node
  }

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

// Driver code
const list = new LinkedList();
list.insertAtBeginning(3);
list.insertAtBeginning(2);
list.insertAtBeginning(1);
list.printList();

const newNode = new Node(value); // create new node

create a new node with the given value

newNode.next = this.head; // link new node to current head

point new node's next to current head to keep the list connected

this.head = newNode; // update head to new node

make new node the new head of the list

Output

1 -> 2 -> 3 -> null

Complexity Analysis

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

Space: O(1) because we create only one new node regardless of list size

vs Alternative: Compared to inserting at the end which requires O(n) time to find the last node, inserting at the beginning is faster and simpler

Edge Cases

empty list (head is null)

new node becomes the head and points to null

DSA Typescript

newNode.next = this.head; // link new node to current head

single element list

new node points to the existing single node, becomes new head

DSA Typescript

this.head = newNode; // update head to new node

When to Use This Pattern

When you need to add an item quickly at the start of a list, use head insert to avoid traversing the list.

Common Mistakes

Mistake: Forgetting to update the head pointer to the new node
Fix: Always assign the new node to head after linking its next pointer

Mistake: Not linking new node's next to the old head, causing list loss
Fix: Set newNode.next = head before updating head

Summary

Adds a new node at the start of a linked list making it the new head.

Use when you want fast insertion at the beginning without traversing the list.

The key is to link the new node to the old head before updating the head pointer.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Adds a new node at the start of the list

B. Adds a new node at the end of the list

C. Deletes the first node of the list

D. Deletes the last node of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means adding a new node before the current first node.

2. Step 2: Effect on the list

   The new node becomes the head, pushing the old head to second position.

3. Final Answer:

   Adds a new node at the start of the list -> Option A

4. Quick Check:

   Insert at beginning = Add new head [OK]

Hint: Insert at beginning means new head node [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it changes the tail node

2. Which of the following is the correct TypeScript syntax to insert a new node at the beginning of a singly linked list?

easy

A. newNode = head; head.next = newNode;

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

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

D. newNode.next = head; head = newNode;

Solution

1. Step 1: Link new node to current head

   Set newNode.next to point to current head node.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the first node.

3. Final Answer:

   newNode.next = head; head = newNode; -> Option D

4. Quick Check:

   Link new node to head, then update head [OK]

Hint: Set newNode.next to head, then head = newNode [OK]

Common Mistakes:

• Assigning head before linking newNode.next
• Swapping assignments order
• Using head.next instead of newNode.next

3. What will be the linked list after executing the following TypeScript code?

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

let head: Node | null = new Node(10);
let newNode = new Node(5);
newNode.next = head;
head = newNode;

medium

A. 10 -> null

B. 10 -> 5 -> null

C. 5 -> 10 -> null

D. 5 -> null

Solution

1. Step 1: Initial list setup

   head points to node with value 10, next is null.

2. Step 2: Insert newNode at beginning

   newNode (5) points to head (10), then head updated to newNode.

3. Final Answer:

   5 -> 10 -> null -> Option C

4. Quick Check:

   New node 5 becomes head, points to 10 [OK]

Hint: New node points to old head, then becomes new head [OK]

Common Mistakes:

• Confusing order of nodes after insertion
• Forgetting to update head
• Assuming newNode.next is null

4. Identify the error in this TypeScript code that tries to insert a node at the beginning of a linked list:

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

let head: Node | null = null;
let newNode = new Node(7);
head.next = newNode;
head = newNode;

medium

A. head is null, so head.next causes an error

B. newNode is not linked to head

C. head should be assigned before newNode.next

D. Missing constructor call for newNode

Solution

1. Step 1: Check initial head value

   head is null, so accessing head.next is invalid and causes runtime error.

2. Step 2: Correct insertion approach

   Assign newNode.next = head (which is null), then head = newNode.

3. Final Answer:

   head is null, so head.next causes an error -> Option A

4. Quick Check:

   Cannot access property on null head [OK]

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

Common Mistakes:

• Trying to access next on null head
• Not linking newNode.next to head
• Assigning head after using head.next

5. Given a singly linked list with nodes 20 -> 30 -> 40 -> null, what will be the list after inserting 10 at the beginning using head insert method?

hard

A. 20 -> 30 -> 40 -> 10 -> null

B. 10 -> 20 -> 30 -> 40 -> null

C. 30 -> 40 -> 10 -> 20 -> null

D. 10 -> 30 -> 40 -> 20 -> null

Solution

1. Step 1: Understand initial list

   List is 20 -> 30 -> 40 -> null, head points to 20.

2. Step 2: Insert 10 at beginning

   Create new node 10, set newNode.next = head (20), then head = newNode.

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> null -> Option B

4. Quick Check:

   New node 10 becomes head, old list follows [OK]

Hint: New node points to old head, becomes new head [OK]

Common Mistakes:

• Appending new node at end instead of beginning
• Mixing node order after insertion
• Not updating head pointer