Insert at Beginning Head Insert in DSA Javascript - 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 bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function insertAtBeginning(head, value) {
  const newNode = { value: value, next: head };
  return newNode;
}
    

This code creates a new node and places it at the start of the list, making it the new head.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating one new node and linking it to the current head.
• How many times: This happens once per insertion, no loops or traversals.

How Execution Grows With Input

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

Input Size (n)	Approx. Operations
10	1 insertion step
100	1 insertion step
1000	1 insertion step

Pattern observation: The time stays constant as the list grows.

Final Time Complexity

Time Complexity: O(1)

This means adding at the start takes the same short time no matter how many items are in the list.

Common Mistake

[X] Wrong: "Adding at the start takes longer as the list grows because the list is bigger."

[OK] Correct: We only change the first node's pointer, no need to look through the list, so time stays the same.

Interview Connect

Knowing that head insertion is quick helps you choose the right method when speed matters in linked lists.

Self-Check

"What if we changed to insert at the end of the list instead? 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 adding a new node before the current first node.

2. Step 2: Effect on the list

   The new node becomes the new 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: Insert at beginning means new head node [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it modifies middle nodes

2. Which of the following is the correct syntax to insert a new node at the beginning of a singly linked list in JavaScript?

easy

A. newNode.next = head; head = newNode;

B. head = newNode.next; newNode = head;

C. head.next = newNode; newNode = head;

D. newNode = head.next; head = newNode;

Solution

1. Step 1: Link new node to current head

   Set newNode.next to point to current head node.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the first node.

3. Final Answer:

   newNode.next = head; head = newNode; -> Option A

4. Quick Check:

   Link new node to head, then update head [OK]

Hint: Set newNode.next = head, then head = newNode [OK]

Common Mistakes:

• Swapping assignments incorrectly
• Not updating head pointer
• Assigning head.next instead of newNode.next

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

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

let head = new Node(10);
let newNode = new Node(20);
newNode.next = head;
head = newNode;

// Print list
let current = head;
let result = [];
while(current) {
  result.push(current.data);
  current = current.next;
}
console.log(result);

medium

A. [20, 10]

B. [10, 20]

C. [10]

D. [20]

Solution

1. Step 1: Insert newNode at beginning

   newNode (20) points to head (10), then head updated to newNode.

2. Step 2: Traverse list from new head

   Traversal order: 20 -> 10 -> null, so result array is [20, 10].

3. Final Answer:

   [20, 10] -> Option A

4. Quick Check:

   New node at head means list starts with 20 [OK]

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

Common Mistakes:

• Reversing order of nodes in output
• Ignoring head update
• Confusing data values

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

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

let head = new Node(5);
let newNode = new Node(15);
head = newNode;
newNode.next = head;

medium

A. The head is not updated to newNode

B. The next pointer of newNode should be null

C. The newNode is not created properly

D. The newNode.next is assigned after head is updated, causing a cycle

Solution

1. Step 1: Analyze assignment order

   head is set to newNode first, then newNode.next is set to head (which is newNode itself).

2. Step 2: Detect cycle creation

   This causes newNode.next to point to itself, creating a cycle and breaking the list.

3. Final Answer:

   The newNode.next is assigned after head is updated, causing a cycle -> Option D

4. Quick Check:

   Assign next before updating head to avoid cycle [OK]

Hint: Assign newNode.next before head update to avoid cycles [OK]

Common Mistakes:

• Assigning head before newNode.next
• Ignoring pointer references
• Assuming newNode.next should be null always

5. Given a linked list with nodes containing values [30, 20, 10] (head is 30), you want to insert nodes with values [40, 50] at the beginning one by one. What will be the final linked list after these insertions?

hard

A. [40, 50, 30, 20, 10]

B. [50, 40, 30, 20, 10]

C. [30, 20, 10, 40, 50]

D. [10, 20, 30, 40, 50]

Solution

1. Step 1: Insert 40 at beginning

   New head becomes 40, list is [40, 30, 20, 10].

2. Step 2: Insert 50 at beginning

   New head becomes 50, list is [50, 40, 30, 20, 10].

3. Final Answer:

   [50, 40, 30, 20, 10] -> Option B

4. Quick Check:

   Each insert adds new head, order reverses insert sequence [OK]

Hint: Last inserted node becomes new head, list grows front [OK]

Common Mistakes:

• Appending instead of prepending
• Reversing insertion order
• Not updating head after each insert