Delete Node at Beginning in DSA Java

Mental Model

Removing the first item means moving the start pointer to the next item, skipping the old first.

Analogy: Imagine a line of people holding hands. To remove the first person, the second person becomes the new front of the line.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, delete node at beginning

Goal: Remove the first node and update the head to the next node

Step 1: store current head (node 1) to delete

head -> [1] -> 2 -> 3 -> null

Why: We keep a reference to the node to remove it safely

Step 2: move head pointer to next node (node 2)

head -> 2 -> 3 -> null

Why: The second node becomes the new first node

Step 3: disconnect old first node (node 1) from list

head -> 2 -> 3 -> null, old node 1 removed

Why: To avoid memory leaks and complete deletion

Result:

head -> 2 -> 3 -> null

Annotated Code

DSA Java

public class LinkedList {
    static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head;

    // Delete node at beginning
    public void deleteAtBeginning() {
        if (head == null) {
            return; // list empty, nothing to delete
        }
        Node temp = head; // store current head
        head = head.next; // move head to next node
        temp.next = null; // disconnect old head
    }

    // Print list
    public void printList() {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) {
                System.out.print(" -> ");
            }
            curr = curr.next;
        }
        System.out.println(" -> null");
    }

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

        System.out.print("Original list: ");
        list.printList();

        list.deleteAtBeginning();

        System.out.print("After deleting at beginning: ");
        list.printList();
    }
}

if (head == null) { return; }

check if list is empty to avoid errors

Node temp = head;

store current head node to remove it safely

head = head.next;

advance head pointer to next node, removing first

temp.next = null;

disconnect old head node to complete deletion

Output

Original list: 1 -> 2 -> 3 -> null

After deleting at beginning: 2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change pointers at the start without traversal

Space: O(1) because no extra space is used besides a temporary pointer

vs Alternative: Compared to deleting at the end which requires traversal O(n), deleting at beginning is faster and simpler

Edge Cases

empty list

function returns immediately without error

DSA Java

if (head == null) { return; }

single node list

head becomes null, list becomes empty

DSA Java

head = head.next;

When to Use This Pattern

When you need to remove the first element quickly from a linked list, use delete at beginning because it only changes one pointer.

Common Mistakes

Mistake: Not checking if the list is empty before deleting
Fix: Add a check if head is null to avoid null pointer errors

Mistake: Not disconnecting the old head node
Fix: Set old head's next to null to fully remove it

Summary

Deletes the first node by moving the head pointer to the next node.

Use when you want to remove the front element of a linked list efficiently.

The key is to update the head pointer and disconnect the old first node.

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