Delete by Value in Doubly Linked List in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the list is empty before deletion.

DSA Typescript

if (this.head === [1]) {
  return;
}

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

Anull

Bfalse

C0

Dundefined

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined instead of null

Checking for 0 or false which are not node values

We check if this.head is null to know if the list is empty.

2fill in blank

medium

Complete the code to move to the next node while searching for the value.

DSA Typescript

while (current !== null && current.data !== value) {
  current = current[1];
}

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

Aprev

Bhead

Cnext

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev which moves backward

Using head or tail which are list ends, not next node

We move to the next node to continue searching forward.

3fill in blank

hard

Fix the error in updating the previous node's next pointer after deletion.

DSA Typescript

if (current.prev !== null) {
  current.prev.[1] = current.next;
}

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

Anext

Bprev

Cdata

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Updating prev instead of next

Trying to update data property

We update the next pointer of the previous node to skip the deleted node.

4fill in blank

hard

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

DSA Typescript

if (current.next !== null) {
  current.next.[1] = current.prev;
} else {
  this.[2] = current.prev;
}

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

Aprev

Bnext

Ctail

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Updating next pointer instead of prev

Updating head instead of tail when deleting last node

The next node's prev pointer is updated to skip the deleted node. If current.next is null, it means we deleted the tail, so update this.tail.

5fill in blank

hard

Fill all three blanks to complete the deleteByValue method in the doubly linked list.

DSA Typescript

deleteByValue(value: number): void {
  if (this.head === [1]) {
    return;
  }
  let current = this.head;
  while (current !== null && current.data !== value) {
    current = current.[2];
  }
  if (current === null) {
    return;
  }
  if (current.prev !== null) {
    current.prev.next = current.next;
  } else {
    this.head = current.next;
  }
  if (current.next !== null) {
    current.next.[3] = current.prev;
  } else {
    this.tail = current.prev;
  }
}

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

Anull

Bnext

Cprev

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined instead of null for empty check

Moving with prev instead of next in the loop

Updating next pointer instead of prev after deletion

The method first checks if the list is empty by comparing this.head to null. Then it moves through the list using next pointers to find the node with the matching value. Finally, it updates the prev pointer of the next node to remove the current node from the list.

Practice

1. What happens when you delete a node by value in a doubly linked list?

easy

A. All nodes are deleted regardless of value

B. The node with the matching value is removed and links are updated

C. Only the first node is deleted no matter the value

D. The list is reversed instead of deleting

Solution

1. Step 1: Identify the node with the given value

   Traverse the list from head to tail to find the node whose value matches the target.

2. Step 2: Remove the node and update links

   Adjust the previous node's next pointer and the next node's previous pointer to exclude the found node.

3. Final Answer:

   The node with the matching value is removed and links are updated -> Option B

4. Quick Check:

   Deleting by value removes matching node [OK]

Hint: Find node by value, then update previous and next links [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Not updating next node's previous pointer
• Deleting all nodes instead of one

2. Which of the following is the correct TypeScript syntax to delete a node by value in a doubly linked list?

easy

A. function deleteNode(value) { /* code */ }

B. removeNode(value: number) => { /* code */ }

C. deleteNode(value: number): void { /* code */ }

D. delete node(value: number) { /* code */ }

Solution

1. Step 1: Check method declaration syntax in TypeScript class

   Methods inside classes use the syntax methodName(params): returnType { body }.

2. Step 2: Identify correct syntax for deleteNode method

   deleteNode(value: number): void { /* code */ } uses correct TypeScript method syntax with type annotation and void return.

3. Final Answer:

   deleteNode(value: number): void { /* code */ } -> Option C

4. Quick Check:

   TypeScript method syntax = deleteNode(value: number): void { /* code */ } [OK]

Hint: Use methodName(params): returnType { } inside class [OK]

Common Mistakes:

• Using arrow function syntax inside class method
• Missing type annotations
• Using invalid keywords like 'delete node'

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> 40, what is the list after deleting the node with value 30?

medium

A. 10 <-> 20 <-> 40

B. 10 <-> 30 <-> 40

C. 20 <-> 30 <-> 40

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

Solution

1. Step 1: Locate node with value 30

   Traverse the list: 10 -> 20 -> 30 found at third node.

2. Step 2: Remove node 30 and link 20 to 40

   Update 20's next pointer to 40 and 40's previous pointer to 20.

3. Final Answer:

   10 <-> 20 <-> 40 -> Option A

4. Quick Check:

   Deleted 30, list links updated [OK]

Hint: Remove node, link previous and next nodes directly [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Not updating next node's previous pointer
• Deleting wrong node

4. What is wrong with this delete function snippet for doubly linked list?

deleteNode(value: number): void {
  let current = this.head;
  while (current !== null) {
    if (current.value === value) {
      current.prev.next = current.next;
      current.next.prev = current.prev;
      break;
    }
    current = current.next;
  }
}

medium

A. It does not handle deleting the head node correctly

B. It deletes all nodes with the value instead of one

C. It uses wrong variable names

D. It causes infinite loop

Solution

1. Step 1: Check handling of head node deletion

   If current is head, current.prev is null, so current.prev.next causes error.

2. Step 2: Identify missing head update

   Function does not update this.head when deleting the first node, causing broken list.

3. Final Answer:

   It does not handle deleting the head node correctly -> Option A

4. Quick Check:

   Head deletion needs special handling [OK]

Hint: Check if node is head before updating prev pointers [OK]

Common Mistakes:

• Not checking if current.prev is null
• Not updating head pointer when deleting first node
• Assuming all nodes have prev and next

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> 25. You want to delete the node with value 5, then delete the node with value 25. What is the final list?

hard

A. 15 <-> 20

B. 5 <-> 10 <-> 15 <-> 20

C. 10 <-> 15 <-> 20 <-> 25

D. 10 <-> 15 <-> 20

Solution

1. Step 1: Delete node with value 5 (head node)

   Update head to 10, set 10.prev to null.

2. Step 2: Delete node with value 25 (tail node)

   Update 20.next to null, removing 25.

3. Final Answer:

   10 <-> 15 <-> 20 -> Option D

4. Quick Check:

   Deleted head and tail nodes correctly [OK]

Hint: Update head or tail pointers when deleting first or last nodes [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating tail when deleting last node
• Breaking links between middle nodes