Delete from Beginning of Doubly Linked List in DSA Java - 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 Java

class Node {
    int data;
    Node prev, next;
    Node(int d) { data = d; prev = next = null; }
}

class DoublyLinkedList {
    Node head;

    void push(int new_data) {
        Node new_node = new Node(new_data);
        new_node.next = head;
        if (head != null) head.prev = new_node;
        head = new_node;
    }

    void deleteFromBeginning() {
        if (head == null) return;
        head = head.next;
        if (head != null) head.prev = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " <-> ");
            temp = temp.next;
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.push(3);
        dll.push(2);
        dll.push(1);
        dll.deleteFromBeginning();
        dll.printList();
    }
}

A 3 <-> 2 <-> null

B 1 <-> 2 <-> 3 <-> null

C null

D 2 <-> 3 <-> null

💡 Hint

Deleting from beginning removes the head node and updates the head pointer.

The list initially is 1 <-> 2 <-> 3 <-> null after pushing 1, 2, 3 in that order.

Deleting from beginning removes the first node (1), so the new head is 2.

Thus, the list becomes 2 <-> 3 <-> null.

🧠 Conceptual

intermediate

Effect of deleting from an empty doubly linked list

What happens when you try to delete the first node from an empty doubly linked list?

A Deletes a random node causing undefined behavior.

B Throws a NullPointerException error.

C Nothing happens; the list remains empty without error.

D Creates a new node with null data.

💡 Hint

Check the delete method's first condition for empty list.

The delete method first checks if the head is null (empty list).

If yes, it returns immediately without changes or errors.

🔧 Debug

advanced

Identify the bug in this delete from beginning method

What error will this deleteFromBeginning method cause when deleting the only node in the list?

DSA Java

void deleteFromBeginning() {
    if (head == null) return;
    head = head.next;
    head.prev = null;
}

A Logical error: deletes last node but does not update head

B NullPointerException when head is the only node

C No error; works correctly

D Syntax error due to missing semicolon

💡 Hint

Consider what happens when head.next is null.

If the list has only one node, head.next is null.

After setting head = head.next, head becomes null.

Then head.prev causes NullPointerException because head is null.

❓ Predict Output

advanced

Output after multiple deletions from beginning

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

DSA Java

class Node {
    int data;
    Node prev, next;
    Node(int d) { data = d; prev = next = null; }
}

class DoublyLinkedList {
    Node head;

    void push(int new_data) {
        Node new_node = new Node(new_data);
        new_node.next = head;
        if (head != null) head.prev = new_node;
        head = new_node;
    }

    void deleteFromBeginning() {
        if (head == null) return;
        head = head.next;
        if (head != null) head.prev = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " <-> ");
            temp = temp.next;
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.push(4);
        dll.push(3);
        dll.push(2);
        dll.push(1);
        dll.deleteFromBeginning();
        dll.deleteFromBeginning();
        dll.printList();
    }
}

A 3 <-> 4 <-> null

B 2 <-> 3 <-> 4 <-> null

C 1 <-> 2 <-> 3 <-> 4 <-> null

D 4 <-> null

💡 Hint

Each deletion removes the current head node.

Initial list after pushes: 1 <-> 2 <-> 3 <-> 4 <-> null

First deletion removes 1, list becomes 2 <-> 3 <-> 4 <-> null

Second deletion removes 2, list becomes 3 <-> 4 <-> null

🧠 Conceptual

expert

Why is updating the prev pointer important when deleting from beginning?

What problem occurs if you delete the first node but do not update the prev pointer of the new head node in a doubly linked list?

A The new head's prev pointer still points to the deleted node, causing incorrect backward traversal.

B The list becomes singly linked automatically.

C The next pointer of the new head becomes null.

D The list will throw a runtime error immediately.

💡 Hint

Think about how backward navigation works in doubly linked lists.

In a doubly linked list, each node's prev points to the previous node.

If after deletion the new head's prev is not set to null, it still points to the removed node.

This causes backward traversal to access invalid memory or wrong nodes.

Practice

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

easy

A. It moves to the second node in the list

B. It becomes null immediately

C. It points to the last node

D. It remains unchanged

Solution

1. Step 1: Understand the head pointer role

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

2. Step 2: Effect of deleting the first node

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

3. Final Answer:

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

4. Quick Check:

   Deleting first node updates head to next node [OK]

Hint: Head always points to first node; update it after deletion [OK]

Common Mistakes:

• Not updating head pointer after deletion
• Setting head to null even if list has more nodes
• Confusing head with tail pointer

2. Which of the following is the correct Java statement to update the prev pointer of the new head node after deleting the first node in a doubly linked list?

easy

A. head = null.prev;

B. head.next = null;

C. head.prev = null;

D. head.prev.next = null;

Solution

1. Step 1: Identify the new head node

   After deleting the first node, the new head is the second node in the list.

2. Step 2: Set the previous pointer of new head to null

   Since the new head is the first node now, its prev pointer must be null to indicate no node before it.

3. Final Answer:

   head.prev = null; -> Option C

4. Quick Check:

   New head prev pointer must be null [OK]

Hint: New head's prev pointer is always null [OK]

Common Mistakes:

• Setting head.next to null instead of head.prev
• Using invalid syntax like null.prev
• Trying to access prev.next which may cause error

3. Consider the following Java code snippet for deleting the first node from a doubly linked list:

if (head == null) return;
head = head.next;
if (head != null) head.prev = null;

What will be the state of the list after deleting the first node from the list 1 <-> 2 <-> 3?

medium

A. 1 <-> 3

B. Empty list

C. 3 only

D. 2 <-> 3

Solution

1. Step 1: Initial list and deletion

   The list is 1 <-> 2 <-> 3. Deleting the first node means removing node with value 1.

2. Step 2: Update head and prev pointer

   Head moves to node 2. Then head.prev is set to null, so node 2 has no previous node.

3. Final Answer:

   2 <-> 3 -> Option D

4. Quick Check:

   First node removed, head points to second node [OK]

Hint: After deletion, head points to second node, prev set null [OK]

Common Mistakes:

• Not setting head.prev to null causing broken links
• Assuming node 1 still exists
• Confusing next and prev pointers

4. The following code attempts to delete the first node from a doubly linked list but causes a runtime error:

if (head == null) return;
head = head.next;
head.prev = null;

What is the error and how to fix it?

medium

A. Syntax error due to missing semicolon; add semicolon after head.prev = null

B. NullPointerException when list has one node; fix by checking if head is null before setting head.prev

C. Logical error: head should not be updated; remove head = head.next

D. No error; code works fine

Solution

1. Step 1: Identify cause of NullPointerException

   If the list has only one node, after head = head.next, head becomes null. Then head.prev causes NullPointerException.

2. Step 2: Fix by checking head before accessing prev

   Add a condition to check if head is not null before setting head.prev = null.

3. Final Answer:

   NullPointerException when list has one node; fix by checking if head is null before setting head.prev -> Option B

4. Quick Check:

   Always check for null before accessing object members [OK]

Hint: Check head != null before head.prev = null to avoid errors [OK]

Common Mistakes:

• Not checking for null causing runtime errors
• Assuming list always has multiple nodes
• Ignoring exception details

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

hard

A. 30 <-> 40

B. 20 <-> 30 <-> 40

C. 40 only

D. Empty list

Solution

1. Step 1: First deletion

   Deleting first node removes 10. Head moves to 20, head.prev set to null. List becomes 20 <-> 30 <-> 40.

2. Step 2: Second deletion

   Deleting first node again removes 20. Head moves to 30, head.prev set to null. List becomes 30 <-> 40.

3. Final Answer:

   30 <-> 40 -> Option A

4. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head forward and updates prev to null [OK]

Common Mistakes:

• Deleting only once instead of twice
• Not updating head.prev after second deletion
• Printing old list without changes