Insert at Beginning Head Insert in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting nodes at the beginning?

Consider the following Java code that inserts nodes at the beginning of a singly linked list. What will be the printed list after all insertions?

DSA Java

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

class LinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

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

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insertAtBeginning(10);
        list.insertAtBeginning(20);
        list.insertAtBeginning(30);
        list.printList();
    }
}

A 30 -> 20 -> 10 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> 10 -> null

D null -> 30 -> 20 -> 10

💡 Hint

Remember that inserting at the beginning means the new node becomes the new head.

Each new node is added before the current head, so the list order is reversed from the insertion order.

🧠 Conceptual

intermediate

What happens to the head pointer after inserting a new node at the beginning?

In a singly linked list, when you insert a new node at the beginning, what happens to the head pointer?

A The head pointer becomes null.

B The head pointer remains unchanged.

C The head pointer moves to the last node.

D The head pointer moves to point to the new node.

💡 Hint

Think about which node is the first node after insertion.

The head pointer must point to the new node because it is now the first node in the list.

🔧 Debug

advanced

Identify the error in this head insertion code snippet

What error will occur when running this code snippet that attempts to insert a node at the beginning of a linked list?

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
    }
}

class LinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head.next;
        head = newNode;
    }
}

A No error, works correctly

B NullPointerException

C Compilation error due to missing semicolon

D StackOverflowError

💡 Hint

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

If head is null, accessing head.next causes NullPointerException.

❓ Predict Output

advanced

What is the list after multiple head insertions and one removal?

Given the following code, what is the printed list after all operations?

DSA Java

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

class LinkedList {
    Node head;

    void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

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

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

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insertAtBeginning(5);
        list.insertAtBeginning(15);
        list.insertAtBeginning(25);
        list.removeFirst();
        list.printList();
    }
}

A 15 -> 5 -> null

B 25 -> 15 -> 5 -> null

C 5 -> 15 -> null

D null

💡 Hint

Removing the first node means the head moves to the next node.

After inserting 25, 15, 5 at beginning, list is 25 -> 15 -> 5 -> null. Removing first node removes 25, so head points to 15.

🧠 Conceptual

expert

Why is inserting at the beginning of a singly linked list efficient?

Why is inserting a new node at the beginning of a singly linked list considered an efficient operation?

A Because it requires sorting the list after insertion.

B Because it requires traversing the entire list to find the insertion point.

C Because it requires updating only the head pointer and the new node's next pointer, both constant time operations.

D Because it requires shifting all existing nodes one position forward.

💡 Hint

Think about how many nodes you need to visit to insert at the beginning.

Inserting at the beginning only changes two pointers, so it takes constant time regardless of list size.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Deletes the last node of the list

B. Adds a new node at the end of the list

C. Adds a new node at the start of the list

D. Deletes the first node of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means placing a new node before the current first node.

2. Step 2: Effect on the list

   The new node becomes the head, pushing the old head to second position.

3. Final Answer:

   Adds a new node at the start of the list -> Option C

4. Quick Check:

   Insert at beginning = Add new head [OK]

Hint: New node becomes head, old head moves next [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it changes the tail node

2. Which of the following is the correct Java syntax to insert a new node at the beginning of a singly linked list named list with value 5?

easy

A. list.insertEnd(5);

B. list.add(5);

C. list.head.next = new Node(5);

D. list.head = new Node(5, list.head);

Solution

1. Step 1: Understand Node constructor

   Assuming Node constructor takes value and next node, new Node(5, list.head) creates a new node pointing to current head.

2. Step 2: Assign new node as head

   Setting list.head = new Node(5, list.head); inserts at beginning correctly.

3. Final Answer:

   list.head = new Node(5, list.head); -> Option D

4. Quick Check:

   New node points to old head, becomes new head [OK]

Hint: New node points to old head, assign new node as head [OK]

Common Mistakes:

• Using add() which may add at end
• Changing next of head instead of head itself
• Using insertEnd() which adds at tail

3. What will be the output linked list after executing the following Java code?

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

Node head = new Node(3, null);
head = new Node(2, head);
head = new Node(1, head);

// Print list
Node temp = head;
while(temp != null) {
  System.out.print(temp.data + " -> ");
  temp = temp.next;
}
System.out.print("null");

medium

A. 3 -> 2 -> 1 -> null

B. 1 -> 2 -> 3 -> null

C. null -> 1 -> 2 -> 3

D. 2 -> 1 -> 3 -> null

Solution

1. Step 1: Trace insertions

   First node: 3 -> null
   Insert 2 at beginning: 2 -> 3 -> null
   Insert 1 at beginning: 1 -> 2 -> 3 -> null

2. Step 2: Print list

   Loop prints nodes in order: 1, 2, 3, then null.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option B

4. Quick Check:

   Head insertions reverse order: 1,2,3 [OK]

Hint: Head insert reverses order of inserted nodes [OK]

Common Mistakes:

• Assuming insertion adds at end
• Printing nodes in wrong order
• Confusing next pointers

4. Identify the error in the following code snippet that tries to insert a new node with value 10 at the beginning of a singly linked list.

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

Node head = null;
Node newNode = new Node(10);
newNode.next = head.next;
head = newNode;

medium

A. Accessing head.next when head is null causes NullPointerException

B. New node is not assigned to head

C. Node constructor is missing next parameter

D. No error, code works fine

Solution

1. Step 1: Analyze head initialization

   Head is null initially, so head.next access is invalid and causes error.

2. Step 2: Identify cause of error

   Trying to assign newNode.next = head.next; throws NullPointerException because head is null.

3. Final Answer:

   Accessing head.next when head is null causes NullPointerException -> Option A

4. Quick Check:

   Null head means head.next invalid [OK]

Hint: Check if head is null before accessing head.next [OK]

Common Mistakes:

• Ignoring null head before accessing next
• Assuming constructor error
• Thinking newNode not assigned to head

5. You have a singly linked list with nodes containing values [4, 5, 6] in that order. You want to insert a new node with value 3 at the beginning. After insertion, you want to print the list in the format shown below.

Which code snippet correctly performs the insertion and prints the list?

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

Node head = new Node(4);
head.next = new Node(5);
head.next.next = new Node(6);

// Insert new node with value 3 at beginning and print list
// Fill in the blanks below

// Insert code here

// Print code here

hard

A. Node newNode = new Node(3);
newNode.next = head;
head = newNode;
Node temp = head;
while(temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.print("null");

B. Node newNode = new Node(3);
head.next = newNode;
newNode.next = null;
Node temp = head;
while(temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.print("null");

C. Node newNode = new Node(3);
head = newNode;
newNode.next = head.next;
Node temp = head;
while(temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.print("null");

D. Node newNode = new Node(3);
newNode.next = null;
head.next = newNode;
Node temp = head;
while(temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.print("null");

Solution

1. Step 1: Insert new node at beginning

   Create new node with value 3, set its next to current head, then update head to new node.

2. Step 2: Print the list

   Traverse from head, print each node's data followed by ' -> ', end with 'null'.

3. Final Answer:

   Code snippet in Option A correctly inserts and prints the list -> Option A

4. Quick Check:

   New node points to old head, head updated [OK]

Hint: New node next = old head; head = new node; print from head [OK]

Common Mistakes:

• Linking new node incorrectly
• Not updating head to new node
• Appending new node at end instead of beginning