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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting nodes at the beginning?

Consider a singly linked list initially empty. We insert nodes with values 10, 20, and 30 at the beginning one by one. What is the final state of the linked list?

DSA C

struct Node {
    int data;
    struct Node* next;
};

struct Node* head = NULL;

void insertAtBeginning(int val) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = val;
    newNode->next = head;
    head = newNode;
}

int main() {
    insertAtBeginning(10);
    insertAtBeginning(20);
    insertAtBeginning(30);
    struct Node* temp = head;
    while(temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
    return 0;
}

A 20 -> 30 -> 10 -> NULL

B 10 -> 20 -> 30 -> NULL

C NULL

D 30 -> 20 -> 10 -> NULL

💡 Hint

Remember, inserting at the beginning means the newest node becomes the head.

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

❓ Predict Output

intermediate

What happens if we insert a node with value 0 at the beginning of a list with 5 -> 15 -> NULL?

Given a linked list with nodes 5 -> 15 -> NULL, we insert a node with value 0 at the beginning. What is the new list?

DSA C

struct Node {
    int data;
    struct Node* next;
};

struct Node* head = NULL;

void insertAtBeginning(int val) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = val;
    newNode->next = head;
    head = newNode;
}

int main() {
    struct Node* first = (struct Node*)malloc(sizeof(struct Node));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    first->data = 5;
    first->next = second;
    second->data = 15;
    second->next = NULL;
    head = first;

    insertAtBeginning(0);

    struct Node* temp = head;
    while(temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
    return 0;
}

A 0 -> 5 -> 15 -> NULL

B 5 -> 15 -> 0 -> NULL

C 15 -> 5 -> 0 -> NULL

D 5 -> 0 -> 15 -> NULL

💡 Hint

Inserting at the beginning changes the head to the new node.

The new node with value 0 becomes the head, so the list starts with 0.

🔧 Debug

advanced

Why does this head insert code cause a segmentation fault?

Identify the bug in the following code that causes a segmentation fault when inserting at the beginning of a linked list.

DSA C

struct Node {
    int data;
    struct Node* next;
};

struct Node* head = NULL;

void insertAtBeginning(int val) {
    struct Node* newNode;
    newNode->data = val;
    newNode->next = head;
    head = newNode;
}

int main() {
    insertAtBeginning(10);
    return 0;
}

A head is not initialized to NULL

B next pointer is not set to NULL

C newNode is not allocated memory before use, causing undefined behavior

D data field is assigned after setting next pointer

💡 Hint

Check if newNode points to valid memory before accessing its fields.

newNode is declared but not assigned memory with malloc, so accessing newNode->data causes a crash.

❓ Predict Output

advanced

What is the output after multiple head insertions with this code?

Given the code below, what is printed after inserting 1, 2, 3 at the beginning in that order?

DSA C

struct Node {
    int data;
    struct Node* next;
};

struct Node* head = NULL;

void insertAtBeginning(int val) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = val;
    newNode->next = head;
    head = newNode;
}

int main() {
    insertAtBeginning(1);
    insertAtBeginning(2);
    insertAtBeginning(3);

    struct Node* temp = head;
    while(temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    return 0;
}

A 1 2 3

B 3 2 1

C 1 3 2

D 2 3 1

💡 Hint

The last inserted node becomes the head.

Each new node is inserted at the front, so the list order is reversed from insertion order.

🧠 Conceptual

expert

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

Choose the correct time complexity for inserting a new node at the beginning (head) of a singly linked list.

A O(1) - Constant time

B O(n) - Linear time

C O(log n) - Logarithmic time

D O(n^2) - Quadratic time

💡 Hint

Inserting at the head does not require traversal of the list.

Insertion at the beginning only changes a few pointers and does not depend on list size, so it is constant time.

Practice

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

easy

A. Deletes the first 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 last 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 inserts in the middle

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

easy

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

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

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

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

Solution

1. Step 1: Assign newNode's next to current head

   This links the new node to the existing list.

2. Step 2: Update head to newNode

   Now the new node is the first node in the list.

3. Final Answer:

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

4. Quick Check:

   Link newNode to head, then update head [OK]

Hint: Point newNode->next to head, then head to newNode [OK]

Common Mistakes:

• Swapping assignments order
• Assigning head to newNode->next incorrectly
• Not updating head pointer

3. What will be the linked list after inserting nodes with values 10, then 20, then 30 at the beginning in that order? Assume the list was initially empty.

medium

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

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

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

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

Solution

1. Step 1: Insert 10 at beginning

   List becomes 10 -> null.

2. Step 2: Insert 20 at beginning

   List becomes 20 -> 10 -> null.

3. Step 3: Insert 30 at beginning

   List becomes 30 -> 20 -> 10 -> null.

4. Final Answer:

   30 -> 20 -> 10 -> null -> Option D

5. Quick Check:

   Last inserted is new head [OK]

Hint: Last inserted node is always head [OK]

Common Mistakes:

• Assuming insertion at end
• Reversing insertion order
• Confusing node values order

4. Given the following code snippet, what is the error that prevents correct insertion at the beginning?

struct Node {
  int data;
  struct Node* next;
};

void insertAtBeginning(struct Node** head, int val) {
  struct Node* newNode = malloc(sizeof(struct Node));
  newNode->data = val;
  newNode->next = NULL;
  *head = newNode;
}

medium

A. malloc size is incorrect

B. newNode->next should point to current head before updating head

C. newNode->data is not assigned

D. head pointer should not be double pointer

Solution

1. Step 1: Check newNode->next assignment

   It is set to NULL, losing the existing list.

2. Step 2: Correct linking

   newNode->next should point to current head before head is updated.

3. Final Answer:

   newNode->next should point to current head before updating head -> Option B

4. Quick Check:

   Link newNode->next to old head before head update [OK]

Hint: Link newNode->next to old head before head update [OK]

Common Mistakes:

• Setting newNode->next to NULL always
• Not using double pointer for head
• Forgetting to assign data

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> null. You want to insert a new node with value 10 at the beginning. After insertion, what will be the correct sequence of nodes?

hard

A. 10 -> 5 -> 15 -> 25 -> null

B. 5 -> 10 -> 15 -> 25 -> null

C. 10 -> 15 -> 25 -> 5 -> null

D. 5 -> 15 -> 25 -> 10 -> null

Solution

1. Step 1: Current list is 5 -> 15 -> 25 -> null

   This is the starting list before insertion.

2. Step 2: Insert 10 at beginning

   New node 10 points to current head (5), then head updated to 10.

3. Final Answer:

   10 -> 5 -> 15 -> 25 -> null -> Option A

4. Quick Check:

   New node becomes head, old head follows [OK]

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

Common Mistakes:

• Inserting at wrong position
• Not updating head pointer
• Linking nodes incorrectly