Delete by Value in Doubly Linked List in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C++

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

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

Ahead

B0

CNULL

Dnullptr

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or NULL instead of nullptr.

Checking if head equals head itself.

We check if head is nullptr to know if the list is empty.

2fill in blank

medium

Complete the code to find the node with the given value.

DSA C++

Node* current = head;
while (current != nullptr && current->data != [1]) {
    current = current->next;
}

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

Avalue

Bval

Cnode

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'data' instead of the variable holding the value.

Using 'node' which is undefined.

We compare current->data with the value to find the node to delete.

3fill in blank

hard

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

DSA C++

if (current->prev != nullptr) {
    current->prev->[1] = current->next;
}

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

Anext

Bprev

Cdata

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Updating prev instead of next.

Trying to update data or value which are not pointers.

We update the previous node's next pointer 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 C++

if (current->next != nullptr) {
    current->next->[1] = current->prev;
}
if (current == [2]) {
    head = current->next;
}

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

Aprev

Bnext

Chead

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using next instead of prev for the first blank.

Comparing current to current instead of head.

We update the next node's prev pointer and if current is head, update head.

5fill in blank

hard

Fill all three blanks to complete the delete by value function in doubly linked list.

DSA C++

void deleteByValue(Node*& head, int value) {
    if (head == [1]) return;
    Node* current = head;
    while (current != nullptr && current->data != value) {
        current = current->next;
    }
    if (current == nullptr) return;
    if (current->prev != nullptr) {
        current->prev->next = current->next;
    }
    if (current->next != nullptr) {
        current->next->[2] = current->prev;
    }
    if (current == [3]) {
        head = current->next;
    }
    delete current;
}

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

Anullptr

Bprev

Chead

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Not checking if list is empty.

Wrong pointer updated for next node's prev.

Not updating head when deleting the first node.

We check if head is nullptr, update next node's prev pointer, and update head if needed.

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 without checking value.

D. The list is reversed instead of deleting.

Solution

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

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

2. Step 2: Update links to remove the node

   Adjust the previous node's next pointer and the next node's previous pointer to bypass the node to be deleted.

3. Final Answer:

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

4. Quick Check:

   Delete by value removes matching node [OK]

Hint: Find node, update previous and next pointers [OK]

Common Mistakes:

• Not updating both previous and next pointers
• Deleting node without checking value
• Deleting all nodes instead of one

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

easy

A. void deleteNode(Node* &head, int val) { /* code */ }

B. void deleteNode(int val) { /* code */ }

C. Node deleteNode(int val) { /* code */ }

D. int deleteNode(Node* head, int val) { /* code */ }

Solution

1. Step 1: Understand parameter passing for head pointer

   Head pointer must be passed by reference to allow modification if the first node is deleted.

2. Step 2: Check function return type

   Deletion functions usually return void as they modify the list in place.

3. Final Answer:

   void deleteNode(Node* &head, int val) { /* code */ } -> Option A

4. Quick Check:

   Pass head by reference and return void [OK]

Hint: Pass head by reference to modify list [OK]

Common Mistakes:

• Passing head by value causing no list update
• Returning Node instead of void
• Missing head pointer parameter

3. What is the output of the following code snippet after deleting value 20 from the doubly linked list?

struct Node {
  int data;
  Node* prev;
  Node* next;
};

// List: 10 <-> 20 <-> 30
// deleteNode(head, 20);
// printList(head);

medium

A. 10 <-> null

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

C. 20 <-> 30 <-> null

D. 10 <-> 30 <-> null

Solution

1. Step 1: Identify node to delete

   Node with value 20 is in the middle of the list 10 <-> 20 <-> 30.

2. Step 2: Update links after deletion

   After deleting 20, 10's next points to 30, and 30's prev points to 10.

3. Final Answer:

   10 <-> 30 <-> null -> Option D

4. Quick Check:

   Middle node deleted, links updated [OK]

Hint: Deleting middle node links neighbors directly [OK]

Common Mistakes:

• Not updating previous pointer of next node
• Not updating next pointer of previous node
• Leaving deleted node linked

4. Identify the bug in this delete by value function for doubly linked list:

void deleteNode(Node* &head, int val) {
  Node* temp = head;
  while (temp != nullptr && temp->data != val) {
    temp = temp->next;
  }
  if (temp == nullptr) return;
  if (temp->prev != nullptr) temp->prev->next = temp->next;
  if (temp->next != nullptr) temp->next->prev = temp->prev;
  delete temp;
}

medium

A. Does not check for null head pointer

B. Deletes all nodes with matching value

C. Does not update head if first node is deleted

D. Deletes node without freeing memory

Solution

1. Step 1: Check head update when deleting first node

   If the node to delete is the head, head pointer must be updated to next node.

2. Step 2: Verify code for head update

   Code does not update head pointer when temp->prev is nullptr (first node).

3. Final Answer:

   Does not update head if first node is deleted -> Option C

4. Quick Check:

   Head update missing for first node deletion [OK]

Hint: Update head if deleting first node [OK]

Common Mistakes:

• Forgetting to update head pointer
• Not handling empty list
• Deleting without checking node existence

5. Given a doubly linked list with nodes: 5 <-> 10 <-> 15 <-> 20, what will be the list after deleting value 5 and then value 20?

hard

A. 10 <-> 15 <-> null

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

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

D. 15 <-> null

Solution

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

   Update head to 10, set 10's prev to nullptr. List becomes 10 <-> 15 <-> 20.

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

   Update 15's next to nullptr. List becomes 10 <-> 15.

3. Final Answer:

   10 <-> 15 <-> null -> Option A

4. Quick Check:

   Deleted head and tail nodes correctly [OK]

Hint: Update head and tail pointers when deleting ends [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating tail when deleting last node
• Leaving dangling pointers