Insert at Beginning of Doubly Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting 10 at the beginning?

Consider a doubly linked list initially containing nodes with values 20 -> 30 -> 40 -> null. We insert a new node with value 10 at the beginning. What is the printed list after insertion?

DSA C

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

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

struct Node* insertAtBeginning(struct Node* head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = head;
    if (head != NULL) {
        head->prev = newNode;
    }
    head = newNode;
    return head;
}

int main() {
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    struct Node* third = (struct Node*)malloc(sizeof(struct Node));

    head->data = 20; head->prev = NULL; head->next = second;
    second->data = 30; second->prev = head; second->next = third;
    third->data = 40; third->prev = second; third->next = NULL;

    head = insertAtBeginning(head, 10);
    printList(head);
    return 0;
}

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

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

C 10 -> 20 -> 30 -> null

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

💡 Hint

Remember to update the previous pointer of the old head node.

When inserting at the beginning, the new node becomes the head. Its next points to the old head, and the old head's prev points back to the new node. The list order becomes 10 -> 20 -> 30 -> 40 -> null.

❓ Predict Output

intermediate

What is the output after inserting 5 at the beginning of an empty list?

Given an empty doubly linked list (head is NULL), we insert a node with value 5 at the beginning. What is the printed list after insertion?

DSA C

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

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

struct Node* insertAtBeginning(struct Node* head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = head;
    if (head != NULL) {
        head->prev = newNode;
    }
    head = newNode;
    return head;
}

int main() {
    struct Node* head = NULL;
    head = insertAtBeginning(head, 5);
    printList(head);
    return 0;
}

A null

B 5 -> null

C 0 -> 5 -> null

D 5 -> 0 -> null

💡 Hint

Inserting into an empty list creates a single node that is both head and tail.

Since the list was empty, the new node with value 5 becomes the only node. The list prints as 5 -> null.

🔧 Debug

advanced

What error occurs when inserting at beginning with missing prev update?

Consider this code snippet for inserting at the beginning of a doubly linked list: struct Node* insertAtBeginning(struct Node* head, int data) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->prev = NULL; newNode->next = head; // Missing: head->prev = newNode; head = newNode; return head; } What error or problem will occur when printing the list after insertion?

A Infinite loop during print due to broken backward links

B Segmentation fault due to invalid prev pointer

C Compilation error due to missing pointer assignment

D No error; list prints correctly

💡 Hint

Think about how the prev pointers help in traversing backward and maintaining list integrity.

If the old head's prev pointer is not updated to the new node, backward links are broken. This can cause infinite loops or incorrect traversal when printing or traversing backward.

🧠 Conceptual

advanced

Why is updating the prev pointer necessary when inserting at the beginning?

In a doubly linked list, when inserting a new node at the beginning, why must we update the previous pointer of the old head node to point to the new node?

A To maintain the backward link so traversal from tail to head works correctly

B To free the old head node from memory

C To avoid memory leaks by deleting the old head

D To make the new node point to the tail of the list

💡 Hint

Think about how doubly linked lists allow traversal in both directions.

The prev pointer of the old head must point to the new node to maintain correct backward traversal from tail to head.

❓ Predict Output

expert

What is the output after multiple insertions at beginning?

Starting with an empty doubly linked list, we insert nodes with values 50, then 40, then 30, then 20, then 10 at the beginning in that order. What is the printed list after all insertions?

DSA C

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

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

struct Node* insertAtBeginning(struct Node* head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = head;
    if (head != NULL) {
        head->prev = newNode;
    }
    head = newNode;
    return head;
}

int main() {
    struct Node* head = NULL;
    head = insertAtBeginning(head, 50);
    head = insertAtBeginning(head, 40);
    head = insertAtBeginning(head, 30);
    head = insertAtBeginning(head, 20);
    head = insertAtBeginning(head, 10);
    printList(head);
    return 0;
}

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

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

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

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

💡 Hint

Each new node becomes the new head, pushing existing nodes to the right.

Inserting at the beginning reverses the order of insertion. The last inserted node (10) becomes the head, followed by 20, 30, 40, and 50.

Practice

1. What is the main purpose of inserting a node at the beginning of a doubly linked list?

easy

A. To add a new node after the tail node

B. To add a new node before the current head node

C. To delete the first node of the list

D. To reverse the entire list

Solution

1. Step 1: Understand the structure of a doubly linked list

   A doubly linked list has nodes connected both forward and backward, with a head and tail.

2. Step 2: Identify what inserting at the beginning means

   Inserting at the beginning means adding a new node before the current head node, making it the new head.

3. Final Answer:

   To add a new node before the current head node -> Option B

4. Quick Check:

   Insert at beginning = add before head [OK]

Hint: Insert at beginning means new node becomes the head [OK]

Common Mistakes:

• Confusing insertion at beginning with insertion at end
• Thinking insertion deletes nodes
• Mixing up head and tail positions

2. Which of the following is the correct way to update the previous pointer of the old head node when inserting a new node at the beginning in C?

easy

A. new_node->prev = old_head;

B. old_head->next = new_node;

C. new_node->next = old_head->prev;

D. old_head->prev = new_node;

Solution

1. Step 1: Identify pointer updates when inserting at beginning

   The new node's next points to old head, and old head's prev points back to new node.

2. Step 2: Choose correct pointer update for old head

   We must set old_head->prev = new_node to link backward to new node.

3. Final Answer:

   old_head->prev = new_node; -> Option D

4. Quick Check:

   Old head prev points to new node [OK]

Hint: Old head's prev points to new node after insertion [OK]

Common Mistakes:

• Setting old_head->next instead of prev
• Assigning new_node->prev incorrectly
• Forgetting to update old head's prev pointer

3. What will be the output of the following code snippet after inserting a node with value 10 at the beginning of the doubly linked list?

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

Node* head = NULL;

void insertAtBeginning(int val) {
  Node* new_node = (Node*)malloc(sizeof(Node));
  new_node->data = val;
  new_node->prev = NULL;
  new_node->next = head;
  if (head != NULL) {
    head->prev = new_node;
  }
  head = new_node;
}

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

medium

A. 10

B. 20 10

C. 10 20

D. 20

Solution

1. Step 1: Trace first insertion insertAtBeginning(20)

   List is empty, new node with 20 becomes head: 20 -> NULL

2. Step 2: Trace second insertion insertAtBeginning(10)

   New node with 10 points next to old head (20), old head prev points to new node, head updated to 10: 10 <-> 20

3. Final Answer:

   10 20 -> Option C

4. Quick Check:

   List after insertions = 10 20 [OK]

Hint: New node becomes head, old head shifts right [OK]

Common Mistakes:

• Printing nodes in reverse order
• Not updating head pointer
• Forgetting to update old head's prev pointer

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

void insertAtBeginning(int val) {
  Node* new_node = (Node*)malloc(sizeof(Node));
  new_node->data = val;
  new_node->prev = NULL;
  new_node->next = head;
  if (head != NULL) {
    head->next = new_node;
  }
  head = new_node;
}

medium

A. head->next should be head->prev when updating old head

B. new_node->prev should not be NULL

C. head pointer should not be updated

D. malloc size is incorrect

Solution

1. Step 1: Check pointer updates for old head

   When inserting at beginning, old head's prev pointer must point to new node, not next.

2. Step 2: Identify incorrect line

   Code uses head->next = new_node; which wrongly sets old head's next pointer instead of prev.

3. Final Answer:

   head->next should be head->prev when updating old head -> Option A

4. Quick Check:

   Old head prev must point to new node [OK]

Hint: Old head prev, not next, points to new node [OK]

Common Mistakes:

• Updating old head's next pointer instead of prev
• Not updating head pointer
• Incorrect malloc size usage

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25. You want to insert a new node with value 1 at the beginning. After insertion, what will be the correct sequence of node values when traversing from head to tail?

medium

A. 1 <-> 5 <-> 15 <-> 25

B. 5 <-> 15 <-> 25 <-> 1

C. 25 <-> 15 <-> 5 <-> 1

D. 1 <-> 15 <-> 5 <-> 25

Solution

1. Step 1: Understand insertion at beginning

   New node with value 1 becomes new head, pointing next to old head (5).

2. Step 2: Update pointers and traverse list

   Sequence after insertion: 1 (head) <-> 5 <-> 15 <-> 25 (tail).

3. Final Answer:

   1 <-> 5 <-> 15 <-> 25 -> Option A

4. Quick Check:

   New head is 1, followed by old nodes [OK]

Hint: New node becomes head, old head shifts right [OK]

Common Mistakes:

• Appending new node at end instead of beginning
• Mixing node order after insertion
• Not updating head pointer