Insert at Beginning Head Insert in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Insert at Beginning' mean in a linked list?

It means adding a new node at the start (head) of the linked list, making it the new first element.

beginner

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

Because it only requires changing the head pointer and the new node's next pointer, so it takes constant time O(1).

beginner

In C++, what pointer changes are needed to insert a new node at the beginning of a singly linked list?

Set the new node's next pointer to the current head, then update the head pointer to the new node.

beginner

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

The old head becomes the second node in the list, as the new node points to it.

beginner

Show the linked list after inserting 10 at the beginning of list: 20 -> 30 -> null

The list becomes: 10 -> 20 -> 30 -> null

What is the time complexity of inserting a node at the beginning of a singly linked list?

A O(1)

B O(n)

C O(log n)

D O(n^2)

Inserting at the beginning only changes pointers and does not depend on list size, so it is O(1).

Which pointer is updated to point to the new node when inserting at the beginning?

A Next pointer of last node

B Tail pointer

C Head pointer

D Previous pointer

The head pointer is updated to point to the new node, making it the first node.

After inserting a new node at the beginning, what does the new node's next pointer point to?

A Old head node

B Itself

C Null

D Tail node

The new node's next pointer points to the old head node to maintain the list.

If the list is empty (head is null), what happens when you insert at the beginning?

A List remains empty

B New node becomes head and next is null

C New node points to itself

D Insertion fails

The new node becomes the head and its next pointer is null since the list was empty.

Which of these is NOT a step in inserting at the beginning of a linked list?

A Create new node

B Set new node's next to current head

C Update head to new node

D Traverse to last node

Traversing to the last node is not needed when inserting at the beginning.

Explain step-by-step how to insert a new node at the beginning of a singly linked list.

Think about how the head pointer changes and how the new node connects to the old list.

Describe what happens to the linked list structure after inserting a node at the beginning.

Visualize the pointers before and after insertion.

Practice

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

easy

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

B. Deletes the first node of the list

C. Adds a new node at the start of the list, making it the new head

D. Searches for a node at the beginning

Solution

1. Step 1: Understand the operation

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

2. Step 2: Effect on the list

   The new node becomes the head, and its next pointer points to the old head.

3. Final Answer:

   Adds a new node at the start of the list, making it the new head -> Option C

4. Quick Check:

   Insert at beginning = new head [OK]

Hint: New node always becomes the head in beginning insert [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it searches instead of inserts

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

easy

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

B. newNode->next = head; head = newNode;

C. head = newNode; newNode->next = head;

D. newNode = head; head = newNode->next;

Solution

1. Step 1: Link new node to current head

   Set newNode->next to point to the current head node.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the new first node.

3. Final Answer:

   newNode->next = head; head = newNode; -> Option B

4. Quick Check:

   Link then update head [OK]

Hint: Set newNode->next first, then update head [OK]

Common Mistakes:

• Updating head before linking newNode->next
• Swapping pointers incorrectly
• Assigning newNode to head->next

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

struct Node { int data; Node* next; };
Node* head = nullptr;
Node* newNode = new Node{10, nullptr};
newNode->next = head;
head = newNode;
newNode = new Node{20, nullptr};
newNode->next = head;
head = newNode;

Print the list from head to end.

medium

A. 20 -> 10 -> null

B. 10 -> 20 -> null

C. null -> 10 -> 20

D. 10 -> null

Solution

1. Step 1: Insert first node with data 10

   head points to node with 10, next is nullptr.

2. Step 2: Insert second node with data 20 at beginning

   newNode->next = head (node 10), head = newNode (node 20).

3. Final Answer:

   20 -> 10 -> null -> Option A

4. Quick Check:

   Last inserted node is head [OK]

Hint: Last inserted node is always head [OK]

Common Mistakes:

• Assuming order is insertion order instead of reversed
• Confusing next pointers
• Ignoring nullptr termination

4. Identify the error in this code snippet for inserting at the beginning of a linked list:

Node* newNode = new Node();
newNode->data = 5;
head = newNode;
newNode->next = head;

medium

A. No error, code is correct

B. newNode->data is not initialized

C. head should be set to nullptr first

D. newNode->next should be assigned before head is updated

Solution

1. Step 1: Check pointer assignments order

   Assigning head = newNode before setting newNode->next causes newNode->next to point to itself.

2. Step 2: Correct order

   newNode->next should be set to current head before updating head to newNode.

3. Final Answer:

   newNode->next should be assigned before head is updated -> Option D

4. Quick Check:

   Link newNode->next before head update [OK]

Hint: Always link newNode->next before changing head [OK]

Common Mistakes:

• Updating head before linking newNode->next
• Forgetting to initialize newNode->data
• Assuming no error in pointer assignments

5. Given a linked list with nodes 30 -> 20 -> 10 -> null, what will be the list after inserting a new node with data 40 at the beginning twice in a row?

hard

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

B. 30 -> 20 -> 10 -> 40 -> 40 -> null

C. 40 -> 30 -> 20 -> 10 -> null

D. 40 -> 30 -> 20 -> 10 -> 40 -> null

Solution

1. Step 1: Insert first 40 at beginning

   New head is 40, next points to old head 30.

2. Step 2: Insert second 40 at beginning

   New head is another 40, next points to previous 40 node.

3. Final Answer:

   40 -> 40 -> 30 -> 20 -> 10 -> null -> Option A

4. Quick Check:

   Each insert adds new head [OK]

Hint: Each insert adds a new head node [OK]

Common Mistakes:

• Assuming duplicate nodes merge
• Inserting at end instead of beginning
• Losing track of next pointers