Delete Node at Beginning in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting the first node in a singly linked list

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

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtBeginning() {
        if (head != null) {
            head = head.next;
        }
    }

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

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(10);
        list.head.next = new Node(20);
        list.head.next.next = new Node(30);

        list.deleteAtBeginning();
        list.printList();
    }
}

A 10 -> 20 -> 30 -> null

B 30 -> null

C null

D 20 -> 30 -> null

💡 Hint

Deleting the first node moves the head pointer to the next node.

Initially, the list is 10 -> 20 -> 30 -> null. Deleting the first node removes 10, so the new head is 20, resulting in 20 -> 30 -> null.

❓ Predict Output

intermediate

Output when deleting from a single-node linked list

What is the printed state of the linked list after deleting the first node when the list has only one node?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtBeginning() {
        if (head != null) {
            head = head.next;
        }
    }

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

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(100);

        list.deleteAtBeginning();
        list.printList();
    }
}

A 0 -> null

B 100 -> null

C null

D Error: NullPointerException

💡 Hint

Deleting the only node should leave the list empty.

The list starts with one node: 100 -> null. After deleting the first node, head becomes null, so the list is empty and prints null.

🔧 Debug

advanced

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

What error will this code produce when deleting the first node of a linked list?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtBeginning() {
        head = head.next.next;
    }

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

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(1);

        list.deleteAtBeginning();
        list.printList();
    }
}

A NullPointerException

B IndexOutOfBoundsException

C SyntaxError

D No error, prints 2 -> null

💡 Hint

Check what happens if head.next is null before accessing head.next.next.

The code tries to assign head = head.next.next without checking if head.next is null. If head.next is null, accessing next on it causes NullPointerException.

🧠 Conceptual

advanced

Effect of deleting the first node on list length

If a singly linked list has 5 nodes, what will be the length of the list after deleting the first node?

A 4

B 5

C 3

D 0

💡 Hint

Deleting one node reduces the count by one.

Deleting the first node removes one node from the list, so the length decreases from 5 to 4.

🚀 Application

expert

Resulting list after multiple deletions at beginning

Given a linked list with nodes 5 -> 10 -> 15 -> 20 -> null, what is the printed list after deleting the first node twice?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtBeginning() {
        if (head != null) {
            head = head.next;
        }
    }

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

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(5);
        list.head.next = new Node(10);
        list.head.next.next = new Node(15);
        list.head.next.next.next = new Node(20);

        list.deleteAtBeginning();
        list.deleteAtBeginning();
        list.printList();
    }
}

A 20 -> null

B 15 -> 20 -> null

C 5 -> 10 -> 15 -> 20 -> null

D 10 -> 15 -> 20 -> null

💡 Hint

Each deletion removes the current head node.

First deletion removes 5, list becomes 10 -> 15 -> 20 -> null. Second deletion removes 10, list becomes 15 -> 20 -> null.

Practice

1. What happens to the head pointer when you delete a node at the beginning of a singly linked list?

easy

A. It moves to the next 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 list.

2. Step 2: Effect of deleting the first node

   Deleting the first node means the head must point to the second node, which becomes the new first node.

3. Final Answer:

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

4. Quick Check:

   Head points to next node after deletion [OK]

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

Common Mistakes:

• Forgetting to update head pointer
• Setting head to null without checking list
• Pointing head to last node incorrectly

2. Which of the following is the correct syntax to delete the first node in a singly linked list in Java?

easy

A. head = head.next;

B. head.next = head;

C. head = null.next;

D. head.next = null;

Solution

1. Step 1: Understand the head pointer update

   To delete the first node, head must point to the second node, which is head.next.

2. Step 2: Check each option

   head = head.next; correctly assigns head to head.next. Others either cause errors or wrong assignments.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   Assign head to next node to delete first [OK]

Hint: Assign head to head.next to delete first node [OK]

Common Mistakes:

• Using head.next = head which reverses links
• Trying to access null.next causing error
• Setting head.next to null which breaks list

3. Given the linked list: 10 -> 20 -> 30 -> null, what will be the list after deleting the node at the beginning using head = head.next;?

medium

A. 10 -> 20 -> 30 -> null

B. 20 -> 30 -> null

C. 30 -> null

D. null

Solution

1. Step 1: Identify the initial list

   The list starts as 10 -> 20 -> 30 -> null, with head pointing to 10.

2. Step 2: Apply deletion by moving head

   Setting head = head.next moves head to 20, so the list becomes 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option B

4. Quick Check:

   Head moves from 10 to 20 after deletion [OK]

Hint: After deletion, head points to second node, list starts there [OK]

Common Mistakes:

• Not updating head pointer
• Assuming first node remains
• Confusing node values after deletion

4. What is wrong with this code snippet for deleting the first node in a singly linked list?

if (head == null) {
    System.out.println("List is empty");
} else {
    head.next = head;
}

medium

A. It correctly deletes the first node

B. It throws a NullPointerException

C. It sets head to null, losing the list

D. It causes the head to point to itself, creating a cycle

Solution

1. Step 1: Analyze the assignment head.next = head

   This sets the next pointer of the first node to point back to itself, creating a cycle.

2. Step 2: Understand the impact on deletion

   The head pointer is not updated, so the first node is not removed and the list structure is broken.

3. Final Answer:

   It causes the head to point to itself, creating a cycle -> Option D

4. Quick Check:

   Incorrect pointer assignment creates cycle [OK]

Hint: Assign head = head.next to delete; avoid head.next = head [OK]

Common Mistakes:

• Confusing head.next = head with head = head.next
• Not checking for empty list before deletion
• Ignoring pointer updates causing cycles

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> 35 -> null. After deleting the first node twice using head = head.next;, what will be the final list?

hard

A. 35 -> null

B. 15 -> 25 -> 35 -> null

C. 25 -> 35 -> null

D. null

Solution

1. Step 1: Initial list and first deletion

   Start: 5 -> 15 -> 25 -> 35 -> null. After first deletion, head moves to 15, list is 15 -> 25 -> 35 -> null.

2. Step 2: Second deletion

   After second deletion, head moves to 25, list is 25 -> 35 -> null.

3. Final Answer:

   25 -> 35 -> null -> Option C

4. Quick Check:

   Two deletions remove first two nodes [OK]

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

Common Mistakes:

• Deleting only once instead of twice
• Confusing node values after multiple deletions
• Not updating head pointer correctly each time