Insert at Beginning Head Insert in DSA Java - Time & Space Complexity

Time Complexity: Insert at Beginning Head Insert

O(1)

Understanding Time Complexity

We want to understand how long it takes to add a new item at the start of a linked list.

How does the time needed change as the list grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

class LinkedList {
    Node head;
    void insertAtBeginning(int value) {
        Node newNode = new Node(value);
        newNode.next = head;
        head = newNode;
    }
}
    

This code adds a new node at the start of a singly linked list.

Identify Repeating Operations

Look for loops or repeated steps that take time.

• Primary operation: Creating a new node and changing pointers.
• How many times: Exactly once per insertion, no loops involved.

How Execution Grows With Input

Adding at the start always takes the same steps, no matter how big the list is.

Input Size (n)	Approx. Operations
10	3 (create node, set next, update head)
100	3 (same steps, no change)
1000	3 (still the same fixed steps)

Pattern observation: The time stays constant regardless of list size.

Final Time Complexity

Time Complexity: O(1)

This means adding at the start takes the same short time no matter how big the list is.

Common Mistake

[X] Wrong: "Adding at the start takes longer as the list grows because we have to move all nodes."

[OK] Correct: We only change a few pointers; we do not move or visit other nodes.

Interview Connect

Knowing this helps you explain why linked lists are good for quick insertions at the front, a common question in interviews.

Self-Check

"What if we changed to insert at the end of the list without a tail pointer? How would the time complexity change?"

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