Insert at Beginning Head Insert in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node and insert it at the beginning of the linked list.

DSA C++

Node* newNode = new Node(data);
newNode->next = [1];
head = newNode;

Drag options to blanks, or click blank then click option'

Adata

Bnullptr

CnewNode

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode->next to nullptr loses the rest of the list.

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

2fill in blank

medium

Complete the code to update the head pointer after inserting the new node at the beginning.

DSA C++

head = [1];

Drag options to blanks, or click blank then click option'

Anullptr

BnewNode

Chead->next

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head to nullptr removes the list.

After linking the new node, head must point to it to mark it as the first node.

3fill in blank

hard

Fix the error in the code that inserts a new node at the beginning of the list.

DSA C++

Node* newNode = new Node(data);
newNode->next = [1];
head = newNode;

Drag options to blanks, or click blank then click option'

AnewNode

Bnullptr

Chead

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode->next to newNode causes a cycle.

The new node's next must point to the current head, not itself or data.

4fill in blank

hard

Fill both blanks to complete the function that inserts a new node at the beginning of the list.

DSA C++

void insertAtBeginning(Node*& head, int data) {
    Node* newNode = new Node(data);
    newNode->next = [1];
    [2] = newNode;
}

Drag options to blanks, or click blank then click option'

Ahead

BnewNode

Chead->next

Dnullptr

Attempts:

3 left

💡 Hint

Common Mistakes

Using head->next instead of head loses the list.

newNode->next should point to head, and head should be updated to newNode.

5fill in blank

hard

Fill all three blanks to complete the code that inserts a new node at the beginning and prints the list.

DSA C++

void insertAtBeginning(Node*& head, int data) {
    Node* newNode = new Node(data);
    newNode->next = [1];
    [2] = newNode;
}

void printList(Node* head) {
    Node* current = head;
    while (current != [3]) {
        std::cout << current->data << " -> ";
        current = current->next;
    }
    std::cout << "null" << std::endl;
}

Drag options to blanks, or click blank then click option'

Ahead

BnewNode

Cnullptr

Dhead->next

Attempts:

3 left

💡 Hint

Common Mistakes

Using head->next instead of head in insertion.

Insert links newNode->next to head and updates head. The print loop ends when current is nullptr.

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