Insert at Beginning of Doubly Linked List in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Typescript

const newNode = new Node([1]);

Drag options to blanks, or click blank then click option'

Anext

Bhead

Cvalue

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' instead of 'value' when creating the new node.

Using 'next' or 'prev' which are pointers, not the data value.

We create a new node by passing the value to the Node constructor.

2fill in blank

medium

Complete the code to link the new node's next pointer to the current head.

DSA Typescript

newNode.next = [1];

Drag options to blanks, or click blank then click option'

AnewNode

Bhead

Cnull

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode.next to itself causing a cycle.

Setting newNode.next to null which breaks the list.

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

3fill in blank

hard

Fix the error in updating the previous pointer of the old head node.

DSA Typescript

if (head !== null) {
  head.[1] = newNode;
}

Drag options to blanks, or click blank then click option'

Anext

Bhead

Cvalue

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Updating 'next' instead of 'prev' pointer.

Trying to update 'value' or 'head' which are not pointers.

The old head's previous pointer should point back to the new node.

4fill in blank

hard

Fill both blanks to update the head pointer and the new node's previous pointer.

DSA Typescript

head = [1];
newNode.[2] = null;

Drag options to blanks, or click blank then click option'

AnewNode

Bhead

Cprev

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Setting head to old head instead of new node.

Setting newNode.next to null instead of newNode.prev.

The head pointer should now point to the new node, and the new node's previous pointer should be null because it is the first node.

5fill in blank

hard

Fill all three blanks to complete the insertAtBeginning function.

DSA Typescript

function insertAtBeginning(head: Node | null, value: number): Node {
  const newNode = new Node([1]);
  newNode.next = [2];
  if (head !== null) {
    head.prev = newNode;
  }
  newNode.prev = null;
  [3] = newNode;
  return [3];
}

Drag options to blanks, or click blank then click option'

Avalue

Bhead

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Not updating the head pointer to the new node.

Returning the old head instead of the new head.

Mixing up the order of assignments.

We create the new node with the value, link its next to the current head, and then update the head pointer to the new node before returning it.

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