Insert at 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 moving forward and backward through the list.

beginner

What steps are needed to insert a new node at the beginning of a doubly linked list?

1. Create a new node with the given data.
2. Set the new node's next pointer to the current head.
3. Set the new node's previous pointer to null.
4. If the list is not empty, set the current head's previous pointer to the new node.
5. Update the head to be the new node.

beginner

Why do we need to update the previous pointer of the old head when inserting at the beginning?

Because the new node becomes the first node, the old head now has a node before it. So, its previous pointer must point to the new node to keep the list connected both ways.

beginner

What happens if the doubly linked list is empty when inserting at the beginning?

The new node becomes the only node in the list. Its next and previous pointers are both null, and the head points to this new node.

intermediate

Show the TypeScript code snippet to insert a node at the beginning of a doubly linked list.

class Node {<br>  data: number;<br>  next: Node | null;<br>  prev: Node | null;<br>  constructor(data: number) {<br>    this.data = data;<br>    this.next = null;<br>    this.prev = null;<br>  }<br>}<br><br>class DoublyLinkedList {<br>  head: Node | null = null;<br><br>  insertAtBeginning(data: number): void {<br>    const newNode = new Node(data);<br>    newNode.next = this.head;<br>    newNode.prev = null;<br>    if (this.head !== null) {<br>      this.head.prev = newNode;<br>    }<br>    this.head = newNode;<br>  }<br>}

What pointer of the new node should be set to null when inserting at the beginning of a doubly linked list?

A next

B none

C both next and prev

D prev

The new node is inserted at the beginning, so its previous pointer should be null because no node comes before it.

When inserting at the beginning, what must be updated if the list is not empty?

A The old head's previous pointer

B The tail pointer

C The new node's previous pointer

D The new node's next pointer

The old head's previous pointer must point to the new node to maintain the doubly linked structure.

If the list is empty, what will the head point to after insertion at the beginning?

A the new node

B null

C the old head

D the tail

The new node becomes the only node, so the head points to it.

Which of these is NOT a part of a doubly linked list node?

A previous pointer

B next pointer

C random pointer

D data

A standard doubly linked list node has data, next, and previous pointers. Random pointer is not standard.

What is the time complexity of inserting a node at the beginning of a doubly linked list?

A O(log n)

B O(1)

C O(n)

D O(n^2)

Insertion at the beginning is done in constant time because it involves only pointer updates.

Explain the process of inserting a new node at the beginning of a doubly linked list.

Think about how pointers change to keep the list connected both ways.

Describe what happens to the pointers when inserting at the beginning of an empty doubly linked list.

No other nodes exist, so pointers are simple.

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