Delete from Beginning of Doubly Linked List in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting the first node from a doubly linked list

What is the printed state of the doubly linked list after deleting the first node?

DSA C++

struct Node {
    int data;
    Node* prev;
    Node* next;
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

void deleteBeginning(Node*& head) {
    if (!head) return;
    Node* temp = head;
    head = head->next;
    if (head) head->prev = nullptr;
    delete temp;
}

void printList(Node* head) {
    while (head) {
        std::cout << head->data << " <-> ";
        head = head->next;
    }
    std::cout << "null" << std::endl;
}

int main() {
    Node* head = new Node(10);
    head->next = new Node(20);
    head->next->prev = head;
    head->next->next = new Node(30);
    head->next->next->prev = head->next;

    deleteBeginning(head);
    printList(head);
    return 0;
}

A 20 <-> 30 <-> null

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

C 30 <-> null

D null

💡 Hint

Deleting the first node moves the head pointer to the next node and updates its prev pointer.

The first node with value 10 is deleted. The head moves to node with value 20, whose prev pointer is set to nullptr. The list now starts at 20 and continues to 30.

❓ Predict Output

intermediate

Output after deleting from an empty doubly linked list

What will be the output when deleting the first node from an empty doubly linked list and then printing it?

DSA C++

struct Node {
    int data;
    Node* prev;
    Node* next;
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

void deleteBeginning(Node*& head) {
    if (!head) return;
    Node* temp = head;
    head = head->next;
    if (head) head->prev = nullptr;
    delete temp;
}

void printList(Node* head) {
    if (!head) std::cout << "null" << std::endl;
    else {
        while (head) {
            std::cout << head->data << " <-> ";
            head = head->next;
        }
        std::cout << "null" << std::endl;
    }
}

int main() {
    Node* head = nullptr;
    deleteBeginning(head);
    printList(head);
    return 0;
}

A Empty list error

B Segmentation fault

C 0 <-> null

D null

💡 Hint

Deleting from an empty list should do nothing and printing should show null.

Since the list is empty (head is nullptr), deleteBeginning returns immediately. Printing shows null indicating an empty list.

🔧 Debug

advanced

Identify the error in deleting the first node of a doubly linked list

What error will this code cause when deleting the first node from a doubly linked list?

DSA C++

struct Node {
    int data;
    Node* prev;
    Node* next;
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

void deleteBeginning(Node*& head) {
    if (!head) return;
    Node* temp = head;
    head = head->next;
    head->prev = nullptr; // Line with potential error
    delete temp;
}

int main() {
    Node* head = new Node(10);
    deleteBeginning(head);
    return 0;
}

A Runtime error: dereferencing nullptr

B Memory leak

C No error, works fine

D Compilation error

💡 Hint

Check what happens if head->next is nullptr before accessing head->prev.

If the list has only one node, after head = head->next, head becomes nullptr. Accessing head->prev causes a runtime error (dereferencing nullptr).

🧠 Conceptual

advanced

Effect of deleting the first node on doubly linked list pointers

After deleting the first node from a doubly linked list, which pointers must be updated to maintain list integrity?

A Only the head pointer

B The prev pointer of the deleted node

C The head pointer and the prev pointer of the new head node

D The next pointer of the deleted node

💡 Hint

Think about what the head points to and what the new first node's prev pointer should be.

The head pointer must move to the next node, and the new head's prev pointer must be set to nullptr to indicate it is the first node.

🚀 Application

expert

Resulting list after multiple deletions from beginning

Given a doubly linked list with nodes 5 <-> 15 <-> 25 <-> 35 <-> null, what is the printed list after deleting the first node twice?

DSA C++

struct Node {
    int data;
    Node* prev;
    Node* next;
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

void deleteBeginning(Node*& head) {
    if (!head) return;
    Node* temp = head;
    head = head->next;
    if (head) head->prev = nullptr;
    delete temp;
}

void printList(Node* head) {
    while (head) {
        std::cout << head->data << " <-> ";
        head = head->next;
    }
    std::cout << "null" << std::endl;
}

int main() {
    Node* head = new Node(5);
    head->next = new Node(15);
    head->next->prev = head;
    head->next->next = new Node(25);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(35);
    head->next->next->next->prev = head->next->next;

    deleteBeginning(head);
    deleteBeginning(head);
    printList(head);
    return 0;
}

A 15 <-> 25 <-> 35 <-> null

B 25 <-> 35 <-> null

C 35 <-> null

D null

💡 Hint

Each deletion removes the first node and updates the head and prev pointers.

First deletion removes 5, list becomes 15 <-> 25 <-> 35. Second deletion removes 15, list becomes 25 <-> 35.

Practice

1. What happens to the head pointer when you delete the first node from a doubly linked list?

easy

A. It points to the last node

B. It becomes null immediately

C. It moves to the second node in the list

D. It remains pointing to the deleted node

Solution

1. Step 1: Understand the head pointer role

   The head points to the first node in the doubly linked list.

2. Step 2: After deletion, update the head pointer

   When the first node is deleted, the head must point to the next node, which becomes the new first node.

3. Final Answer:

   It moves to the second node in the list -> Option C

4. Quick Check:

   Head points to new first node after deletion [OK]

Hint: Head always moves to next node after deleting first [OK]

Common Mistakes:

• Not updating head pointer after deletion
• Setting head to null without checking list size
• Leaving head pointing to deleted node

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

easy

A. head = head->next; delete head->prev; head->prev = nullptr;

B. Node* temp = head; head = head->next; head->prev = nullptr; delete temp;

C. head->prev = nullptr; delete head; head = head->next;

D. delete head; head = head->next; head->prev = nullptr;

Solution

1. Step 1: Store current head in temp

   We save the current first node in a temporary pointer to delete it safely after updating head.

2. Step 2: Update head and fix previous pointer

   Set head to the next node, then set head->prev to nullptr to detach the old first node.

3. Step 3: Delete the old first node

   Finally, delete the node stored in temp to free memory.

4. Final Answer:

   Node* temp = head; head = head->next; head->prev = nullptr; delete temp; -> Option B

5. Quick Check:

   Proper order: save, update, fix pointers, delete [OK]

Hint: Save head first, update pointers, then delete saved node [OK]

Common Mistakes:

• Deleting head before updating pointers
• Not setting head->prev to nullptr
• Accessing head->prev when head is nullptr

3. What will be the output of the following code snippet after deleting the first node?

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

Node* head = new Node{1, nullptr, nullptr};
Node* second = new Node{2, head, nullptr};
head->next = second;

// Delete from beginning
Node* temp = head;
head = head->next;
head->prev = nullptr;
delete temp;

// Print list
Node* curr = head;
while(curr != nullptr) {
  std::cout << curr->data << " ";
  curr = curr->next;
}

medium

A. 1 2

B. No output (runtime error)

C. 1

D. 2

Solution

1. Step 1: Initial list setup

   List has two nodes: 1 (head) -> 2. Head points to node with data 1.

2. Step 2: Delete first node and update pointers

   Head moves to second node (data 2), and its prev is set to nullptr. The first node is deleted.

3. Step 3: Print remaining list

   Only node with data 2 remains, so output is "2".

4. Final Answer:

   2 -> Option D

5. Quick Check:

   After deletion, list starts at 2 [OK]

Hint: After deleting head, print starts from new head [OK]

Common Mistakes:

• Printing deleted node's data
• Not updating head->prev to nullptr
• Assuming both nodes print after deletion

4. Identify the error in the following code that deletes the first node of a doubly linked list:

void deleteBeginning(Node*& head) {
  if (head == nullptr) return;
  delete head;
  head = head->next;
  if (head != nullptr) head->prev = nullptr;
}

medium

A. Deleting head before updating head pointer causes undefined behavior

B. Missing check if head->next is nullptr

C. head->prev should be set to head->next

D. No error, code works fine

Solution

1. Step 1: Analyze deletion order

   The code deletes head first, then tries to access head->next, which is invalid after deletion.

2. Step 2: Correct order to avoid undefined behavior

   First save head->next in a temp pointer, update head, then delete old node.

3. Final Answer:

   Deleting head before updating head pointer causes undefined behavior -> Option A

4. Quick Check:

   Accessing deleted memory causes error [OK]

Hint: Always update pointers before deleting nodes [OK]

Common Mistakes:

• Deleting node before updating pointers
• Accessing deleted node's members
• Not checking for empty list

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30 <-> 40. After deleting the first node twice from the beginning, what will be the printed list?

hard

A. 30 <-> 40

B. 20 <-> 30 <-> 40

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

D. 40

Solution

1. Step 1: Initial list nodes

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

2. Step 2: First deletion

   Delete node 10, head moves to 20, set head->prev = nullptr. List now: 20 <-> 30 <-> 40.

3. Step 3: Second deletion

   Delete node 20, head moves to 30, set head->prev = nullptr. List now: 30 <-> 40.

4. Final Answer:

   30 <-> 40 -> Option A

5. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head to next node [OK]

Common Mistakes:

• Deleting only once instead of twice
• Not updating head->prev after second deletion
• Printing old list without deletions