Insert at End of Doubly Linked List in DSA C - Build from Scratch

Insert at End of Doubly Linked List

📖 Scenario: You are building a simple program to manage a list of tasks. Each task is stored in a doubly linked list node. You want to add new tasks to the end of the list.

🎯 Goal: Learn how to insert a new node at the end of a doubly linked list and print the list from start to end.

📋 What You'll Learn

Create a doubly linked list node structure with data, prev, and next pointers.

Initialize an empty doubly linked list with a head pointer.

Write a function to insert a new node at the end of the doubly linked list.

Write a function to print the doubly linked list from head to end.

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in many applications like browser history, music playlists, and undo-redo features where you need to move forward and backward easily.

💼 Career

Understanding linked lists is fundamental for software developers, especially for roles involving system programming, embedded systems, or any application requiring efficient dynamic data management.

1

Create the doubly linked list node and initialize head

Define a struct called Node with an int data, a Node* called prev, and a Node* called next. Then create a Node* variable called head and set it to NULL.

DSA C

# Define the Node struct and initialize head
// Your code here

Hint

Use typedef struct Node to define the node. Initialize head as NULL to show the list is empty.

2

Create a function to insert a new node at the end

Write a function called insertAtEnd that takes an int data parameter. Inside, create a new Node* called newNode using malloc. Set newNode->data to data, and both newNode->prev and newNode->next to NULL. If head is NULL, set head to newNode. Otherwise, traverse the list to find the last node, then set its next to newNode and newNode->prev to that last node.

DSA C

#include 
#include 

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

Node* head = NULL;

// Write insertAtEnd function here
// Your code here

Hint

Remember to handle the empty list case by setting head to the new node. Otherwise, find the last node and link the new node after it.

3

Create a function to print the doubly linked list

Write a function called printList that starts from head and uses a while loop to print each node's data followed by -> . Stop when the current node is NULL. After the loop, print NULL.

DSA C

#include 
#include 

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

Node* head = NULL;

void insertAtEnd(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (head == NULL) {
        head = newNode;
        return;
    }

    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }

    temp->next = newNode;
    newNode->prev = temp;
}

// Write printList function here
// Your code here

Hint

Use a temporary pointer to walk through the list from head to NULL. Print each node's data followed by an arrow.

4

Insert nodes and print the list

Call insertAtEnd three times to add nodes with data 10, 20, and 30. Then call printList() to display the list.

DSA C

#include 
#include 

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

Node* head = NULL;

void insertAtEnd(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (head == NULL) {
        head = newNode;
        return;
    }

    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }

    temp->next = newNode;
    newNode->prev = temp;
}

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

// Insert nodes and print the list
// Your code here

Hint

Call insertAtEnd with 10, 20, and 30. Then call printList() to see the list.

Practice

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

easy

A. To add a new element after the last node

B. To remove the first node

C. To reverse the list

D. To find the middle node

Solution

1. Step 1: Understand the list structure

   A doubly linked list has nodes connected forward and backward, allowing traversal in both directions.

2. Step 2: Purpose of insertion at end

   Inserting at the end means adding a new node after the last node, extending the list.

3. Final Answer:

   To add a new element after the last node -> Option A

4. Quick Check:

   Insert at end = add after last node [OK]

Hint: Insert at end means add after last node [OK]

Common Mistakes:

• Confusing insertion at end with deletion
• Thinking insertion happens at the start
• Mixing up singly and doubly linked list operations

2. Which of the following is the correct way to update the 'next' pointer of the last node when inserting a new node at the end in C?

easy

A. last->next = newNode;

B. newNode->next = last;

C. last->prev = newNode;

D. newNode->prev = NULL;

Solution

1. Step 1: Identify the last node's next pointer

   The last node's 'next' pointer should point to the new node to link it at the end.

2. Step 2: Correct pointer assignment

   Assigning 'last->next = newNode;' correctly links the new node after the last node.

3. Final Answer:

   last->next = newNode; -> Option A

4. Quick Check:

   Last node's next points to new node [OK]

Hint: Last node's next points to new node [OK]

Common Mistakes:

• Assigning newNode->next to last (wrong direction)
• Changing last->prev instead of last->next
• Setting newNode->prev to NULL instead of last

3. What will be the output of the following code snippet after inserting a node with value 5 at the end of the doubly linked list 1 <-> 3 <-> 4?

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

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

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

int main() {
  struct Node* head = malloc(sizeof(struct Node));
  head->data = 1; head->prev = NULL;
  struct Node* second = malloc(sizeof(struct Node));
  second->data = 3; second->prev = head; head->next = second;
  struct Node* third = malloc(sizeof(struct Node));
  third->data = 4; third->prev = second; second->next = third; third->next = NULL;
  insertEnd(&head, 5);
  printList(head);
  return 0;
}

medium

A. 1 3 4 0

B. 1 3 4 5

C. 1 3 4

D. 5 1 3 4

Solution

1. Step 1: Understand initial list and insertion

   The list is 1 <-> 3 <-> 4. The function inserts 5 at the end by traversing to last node (4) and linking new node after it.

2. Step 2: Trace printList output

   After insertion, list is 1 <-> 3 <-> 4 <-> 5. Printing nodes in order outputs "1 3 4 5 "

3. Final Answer:

   1 3 4 5 -> Option B

4. Quick Check:

   List after insertEnd = 1 3 4 5 [OK]

Hint: Traverse to last, link new node, print all nodes [OK]

Common Mistakes:

• Not setting newNode->prev correctly
• Forgetting to set last node's next to newNode
• Printing before insertion

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

void insertEnd(struct Node** head, int val) {
  struct Node* newNode = malloc(sizeof(struct Node));
  newNode->data = val;
  newNode->next = NULL;
  if (*head == NULL) {
    *head = newNode;
    return;
  }
  struct Node* temp = *head;
  while (temp->next != NULL) {
    temp = temp->next;
  }
  temp->next = newNode;
}

medium

A. Wrong condition in while loop

B. Incorrect malloc size

C. Missing setting newNode->prev pointer

D. Not updating head pointer

Solution

1. Step 1: Check pointer assignments for doubly linked list

   In doubly linked list, newNode->prev must point to the last node (temp) after insertion.

2. Step 2: Identify missing pointer update

   The code sets temp->next = newNode but does not set newNode->prev = temp, breaking backward link.

3. Final Answer:

   Missing setting newNode->prev pointer -> Option C

4. Quick Check:

   newNode->prev must be set [OK]

Hint: Always set newNode->prev to last node [OK]

Common Mistakes:

• Forgetting newNode->prev assignment
• Assuming singly linked list logic applies
• Not handling empty list case

5. Given a doubly linked list with nodes 10 <-> 20 <-> 30, write the sequence of pointer changes when inserting a new node with value 40 at the end. Which of the following correctly describes the final connections?

hard

A. newNode->prev = NULL; newNode->next = NULL; last->next = NULL

B. newNode->next = last; last->prev = newNode; newNode->prev = NULL

C. last->prev = newNode; newNode->next = last; newNode->prev = NULL

D. last->next = newNode; newNode->prev = last; newNode->next = NULL

Solution

1. Step 1: Identify last node and new node pointers

   Last node is 30. New node 40 should be linked after 30 with next NULL.

2. Step 2: Correct pointer assignments

   Set last->next = newNode to link forward, newNode->prev = last for backward link, and newNode->next = NULL as it is new end.

3. Final Answer:

   last->next = newNode; newNode->prev = last; newNode->next = NULL -> Option D

4. Quick Check:

   New node linked after last with proper prev and next [OK]

Hint: New node's prev = last; last's next = new node; new node's next = NULL [OK]

Common Mistakes:

• Reversing prev and next pointers
• Setting newNode->prev to NULL incorrectly
• Not setting last->next to newNode