Insert at Beginning of Doubly Linked List in DSA Typescript

Mental Model

Add a new node at the start by linking it before the current first node and updating the head pointer.

Analogy: Imagine adding a new first book to a shelf where each book knows the one before and after it; you place the new book at the front and connect it to the old first book.

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

Dry Run Walkthrough

Input: list: 1 ↔ 2 ↔ 3, insert value 0 at beginning

Goal: Add a new node with value 0 at the start so it becomes the new head

Step 1: Create new node with value 0

null ← 1 ↔ 2 ↔ 3 -> null
↑head
newNode(0)

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

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

newNode(0) -> 1 ↔ 2 ↔ 3 -> null
null ← 1 ↔ 2 ↔ 3 -> null
↑head

Why: Link new node forward to the old first node

Step 3: Set current head's previous pointer to new node

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

Why: Link old first node backward to new node

Step 4: Update head pointer to new node

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

Why: New node is now the first node in the list

Result:

null ← 0 ↔ 1 ↔ 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;

  constructor() {
    this.head = null;
  }

  insertAtBeginning(value: number): void {
    const newNode = new Node(value); // create new node
    if (this.head === null) {
      this.head = newNode; // empty list, new node is head
      return;
    }
    newNode.next = this.head; // link new node forward to old head
    this.head.prev = newNode; // link old head backward to new node
    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 dll = new DoublyLinkedList();
dll.insertAtBeginning(3);
dll.insertAtBeginning(2);
dll.insertAtBeginning(1);
console.log('Before insertion:');
dll.printList();
dll.insertAtBeginning(0);
console.log('After insertion of 0 at beginning:');
dll.printList();

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

create a new node with the given value

if (this.head === null) { this.head = newNode; // empty list, new node is head return; }

handle empty list by setting new node as head

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

point new node's next to current head

this.head.prev = newNode; // link old head backward to new node

point old head's prev to new node

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

update head pointer to new node

Output

Before insertion:

1 ↔ 2 ↔ 3 ↔ null

After insertion of 0 at beginning:

0 ↔ 1 ↔ 2 ↔ 3 ↔ null

Complexity Analysis

Time: O(1) because insertion at the beginning only changes a few pointers without traversal

Space: O(1) because only one new node is created regardless of list size

vs Alternative: Compared to inserting at the end which may require traversing the whole list (O(n)), this is faster and simpler

Edge Cases

empty list

new node becomes the head with no next or prev nodes

DSA Typescript

if (this.head === null) {
      this.head = newNode; // empty list, new node is head
      return;
    }

list with one node

new node links correctly before the single existing node

DSA Typescript

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

When to Use This Pattern

When you need to add an element quickly at the start of a list and maintain two-way links, use insert at beginning of doubly linked list for O(1) insertion.

Common Mistakes

Mistake: Forgetting to update the old head's prev pointer to the new node
Fix: Always set old head's prev to new node after linking new node's next to old head

Mistake: Not handling empty list case causing null pointer errors
Fix: Check if head is null and set new node as head directly

Summary

Adds a new node at the start of a doubly linked list by updating pointers and head.

Use it when you want to insert quickly at the front without traversing the list.

The key is to link the new node before the current head and update the head pointer.

Practice

1. What is the main purpose of inserting a node at the beginning of a doubly linked list?

easy

A. To reverse the entire list

B. To add a new node after the tail node

C. To delete the first node in the list

D. To add a new node before the current head node

Solution

1. Step 1: Understand the head node position

   The head node is the first node in the doubly linked list.

2. Step 2: Insert new node before head

   Inserting at the beginning means placing the new node before the current head, making it the new head.

3. Final Answer:

   To add a new node before the current head node -> Option D

4. Quick Check:

   Insert at beginning = add before head [OK]

Hint: Beginning means before the head node [OK]

Common Mistakes:

• Confusing insertion at beginning with insertion at end
• Thinking insertion deletes nodes
• Mixing up head and tail nodes

2. Which of the following TypeScript code snippets correctly creates a new node and inserts it at the beginning of a doubly linked list?

easy

A. newNode.next = head; if(head) head.prev = newNode; head = newNode;

B. newNode.prev = head; if(head) head.next = newNode; head = newNode;

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

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

Solution

1. Step 1: Set newNode.next to current head

   The new node's next pointer should point to the current head node.

2. Step 2: Update current head's prev to newNode if head exists

   If the list is not empty, the current head's prev pointer must point back to the new node.

3. Step 3: Update head to newNode

   Finally, the head pointer is updated to the new node.

4. Final Answer:

   newNode.next = head; if(head) head.prev = newNode; head = newNode; -> Option A

5. Quick Check:

   Set newNode.next=head, head.prev=newNode, head=newNode [OK]

Hint: newNode.next = head; head.prev = newNode; head = newNode [OK]

Common Mistakes:

• Swapping next and prev pointers
• Not updating head pointer
• Setting newNode.prev incorrectly

3. Given the following TypeScript code for a doubly linked list insertion at beginning, what will be the printed list after insertion?

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

let head: Node | null = new Node(10);
head.next = new Node(20);
head.next.prev = head;

const newNode = new Node(5);
newNode.next = head;
head.prev = newNode;
head = newNode;

// Print list
let temp = head;
const result: number[] = [];
while(temp) {
  result.push(temp.data);
  temp = temp.next;
}
console.log(result);

medium

A. [5, 10, 20]

B. [10, 20, 5]

C. [20, 10, 5]

D. [5, 20, 10]

Solution

1. Step 1: Initial list before insertion

   List is 10 <-> 20, head points to 10.

2. Step 2: Insert newNode with data 5 at beginning

   newNode.next = head (10), head.prev = newNode, head = newNode (5).

3. Step 3: Traverse list from new head

   Traverse from 5: 5 -> 10 -> 20.

4. Final Answer:

   [5, 10, 20] -> Option A

5. Quick Check:

   New head 5 followed by 10 and 20 [OK]

Hint: New node becomes head, list order starts with new node [OK]

Common Mistakes:

• Not updating head to newNode
• Incorrectly linking prev pointers
• Printing list from old head

4. Identify the error in the following TypeScript code that attempts to insert a node at the beginning of a doubly linked list:

const newNode = new Node(15);
newNode.prev = null;
newNode.next = head;
head.prev = newNode;
head = newNode;

medium

A. newNode.prev should point to head

B. Missing check if head is null before accessing head.prev

C. head should be assigned before setting newNode.next

D. newNode.next should be null

Solution

1. Step 1: Check if head is null before accessing head.prev

   If the list is empty (head is null), accessing head.prev causes an error.

2. Step 2: Add condition to update head.prev only if head exists

   Use if(head) head.prev = newNode; to avoid runtime error.

3. Final Answer:

   Missing check if head is null before accessing head.prev -> Option B

4. Quick Check:

   Always check head before head.prev [OK]

Hint: Check if head exists before accessing its properties [OK]

Common Mistakes:

• Ignoring null head and causing runtime error
• Swapping next and prev pointers
• Assigning head too early

5. You have a doubly linked list with nodes containing values [30, 40, 50]. You want to insert a new node with value 20 at the beginning. After insertion, which of the following correctly represents the list and the pointers of the new head node?

hard

A. List: 20 <-> 30 <-> 40 <-> 50; new head prev points to 30, next = null

B. List: 30 <-> 40 <-> 50 <-> 20; new head prev = 50, next = null

C. List: 20 <-> 30 <-> 40 <-> 50; new head prev = null, next points to 30

D. List: 50 <-> 40 <-> 30 <-> 20; new head prev = null, next points to 40

Solution

1. Step 1: Insert new node with value 20 before current head 30

   New node becomes head, its prev is null, next points to old head (30).

2. Step 2: Update old head's prev to new node

   Old head (30) prev pointer updated to new node (20).

3. Step 3: Confirm list order and pointers

   List order is 20 <-> 30 <-> 40 <-> 50 with new head prev=null, next=30.

4. Final Answer:

   List: 20 <-> 30 <-> 40 <-> 50; new head prev = null, next points to 30 -> Option C

5. Quick Check:

   New head prev=null, next=old head [OK]

Hint: New head prev always null, next points to old head [OK]

Common Mistakes:

• Setting new head prev to old tail
• Reversing list order accidentally
• Not updating old head prev pointer