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

Insert at End of Circular Linked List

📖 Scenario: You are managing a circular linked list that represents a round-robin queue of tasks. Each node holds a task number. You want to add a new task at the end of this circular list.

🎯 Goal: Build a C program that creates a circular linked list with initial tasks, sets up a new task number, inserts this new task at the end of the circular linked list, and then prints the list to show the updated order.

📋 What You'll Learn

Define a struct called Node with an integer data and a pointer next.

Create a circular linked list with exactly three nodes having data values 10, 20, and 30.

Create an integer variable called new_data and set it to 40.

Write a function called insertAtEnd that takes a pointer to the head node and an integer, and inserts a new node with that integer at the end of the circular linked list.

Print the circular linked list starting from the head node, showing all node data separated by -> and ending with (head) to indicate circularity.

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real-time systems like task scheduling where the tasks repeat in a cycle.

💼 Career

Understanding circular linked lists and insertion operations is important for software engineers working on embedded systems, operating systems, and game development.

1

Create the initial circular linked list

Define a struct called Node with an integer data and a pointer next. Then create three nodes with data 10, 20, and 30 linked in a circular way. Store the pointer to the first node in a variable called head.

DSA C

// Define struct Node and create circular linked list with nodes 10, 20, 30
// Your code here

Hint

Remember to link the last node's next pointer back to head to make the list circular.

2

Add a new data variable for insertion

Create an integer variable called new_data and set it to 40.

DSA C

#include 
#include 

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

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

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = head;

    // Create new_data variable
    // Your code here

    return 0;
}

Hint

Just declare an integer variable named new_data and assign it the value 40.

3

Write the insertAtEnd function

Write a function called insertAtEnd that takes a pointer to Node called head and an integer data. This function should create a new node with data and insert it at the end of the circular linked list. The function should return the (possibly new) head pointer.

DSA C

#include 
#include 

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

Node* insertAtEnd(Node* head, int data) {
    // Write code to insert new node at end of circular linked list
    // Your code here
}

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

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = head;

    int new_data = 40;

    // Call insertAtEnd function
    // Your code here

    return 0;
}

Hint

Create a new node, find the last node by checking temp->next != head, then link the new node at the end and point it back to head.

4

Print the circular linked list

Write code to print the circular linked list starting from head. Print each node's data followed by ->. After printing all nodes, print (head) to show the list is circular.

DSA C

#include 
#include 

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

Node* insertAtEnd(Node* head, int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;

    if (head == NULL) {
        new_node->next = new_node;
        return new_node;
    }

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

    temp->next = new_node;
    new_node->next = head;

    return head;
}

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

    head->data = 10;
    head->next = second;

    second->data = 20;
    second->next = third;

    third->data = 30;
    third->next = head;

    int new_data = 40;

    head = insertAtEnd(head, new_data);

    // Print the circular linked list
    // Your code here

    return 0;
}

Hint

Use a do-while loop to print each node's data until you reach the head again, then print (head).

Practice

1. What happens when you insert a new node at the end of a circular linked list that currently has 3 nodes?

easy

A. The new node becomes the head node and points to the second node.

B. The new node becomes the last node and points back to the head node.

C. The new node is inserted in the middle of the list.

D. The list breaks and becomes a linear linked list.

Solution

1. Step 1: Understand circular linked list structure

   In a circular linked list, the last node points back to the head node, forming a circle.

2. Step 2: Insert new node at end

   The new node is linked after the current last node, and its next pointer points to the head node, maintaining the circle.

3. Final Answer:

   The new node becomes the last node and points back to the head node. -> Option B

4. Quick Check:

   New node points to head, preserving circular link [OK]

Hint: New end node always points to head in circular list [OK]

Common Mistakes:

• Forgetting to link new node back to head
• Inserting node at wrong position
• Breaking the circular link

2. Which of the following is the correct syntax to create a new node in C for a circular linked list?

easy

A. struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

B. newNode = malloc(sizeof(Node));

C. struct Node newNode = malloc(sizeof(struct Node));

D. Node* newNode = new Node();

Solution

1. Step 1: Allocate memory for new node

   In C, use malloc with sizeof(struct Node) and cast to (struct Node*).

2. Step 2: Correct pointer declaration

   Declare newNode as a pointer to struct Node to hold the allocated memory address.

3. Final Answer:

   struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); -> Option A

4. Quick Check:

   Proper malloc and pointer cast in C [OK]

Hint: Use malloc with sizeof(struct Node) and cast to struct Node* [OK]

Common Mistakes:

• Missing (struct Node*) cast
• Declaring newNode as struct Node instead of pointer
• Using C++ style new operator in C

3. Given the following code snippet for inserting at the end of a circular linked list, what will be the printed list after insertion?

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

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

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 = 1; head->next = second;
  second->data = 2; second->next = third;
  third->data = 3; third->next = head;

  // Insert new node with data 4 at end
  struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  newNode->data = 4;
  newNode->next = head;
  third->next = newNode;

  printList(head);
  return 0;
}

medium

A. 1 -> 2 -> 3 -> 4 -> 1 -> ... (infinite loop)

B. 1 -> 2 -> 3 -> NULL

C. 3 -> 4 -> 1 -> 2 -> NULL

D. 1 -> 2 -> 3 -> 4 -> NULL

Solution

1. Step 1: Understand list before insertion

   Initial list is 1 -> 2 -> 3 -> back to 1 (circular).

2. Step 2: Insert new node at end

   New node with data 4 points to head; third node points to new node, extending list to 1 -> 2 -> 3 -> 4 -> back to 1.

3. Step 3: Print list

   printList prints nodes until it reaches head again, so output is 1 -> 2 -> 3 -> 4 -> NULL.

4. Final Answer:

   1 -> 2 -> 3 -> 4 -> NULL -> Option D

5. Quick Check:

   New node added at end, circular link maintained [OK]

Hint: New node points to head; last node points to new node [OK]

Common Mistakes:

• Printing infinite loop by not stopping at head
• Forgetting to update last node's next pointer
• Incorrect print format

4. Identify the error in the following code snippet that attempts to insert a new node at the end of a circular linked list:

void insertEnd(struct Node** head, int data) {
  struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  newNode->data = data;
  newNode->next = *head;

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

medium

A. The function should not use double pointer for head.

B. newNode->next should be NULL instead of *head.

C. The while loop condition should check for temp->next != *head instead of NULL.

D. Memory allocation for newNode is missing.

Solution

1. Step 1: Analyze loop condition in circular list

   In a circular linked list, last node's next points to head, not NULL.

2. Step 2: Correct loop condition

   Loop should continue until temp->next equals head, not NULL, to find last node.

3. Final Answer:

   The while loop condition should check for temp->next != *head instead of NULL. -> Option C

4. Quick Check:

   Loop must detect circular end by comparing to head [OK]

Hint: In circular list, last node points to head, not NULL [OK]

Common Mistakes:

• Using NULL to detect end in circular list
• Setting newNode->next to NULL
• Not updating last node's next pointer

5. You have a circular linked list with only one node where head points to itself. You want to insert a new node at the end. Which sequence of steps correctly updates the list?

hard

A. Create new node, set newNode->next = head->next, set head->next = newNode.

B. Create new node, set newNode->next = head, set head->next = newNode, then update head to newNode.

C. Create new node, set newNode->next = NULL, set head->next = newNode.

D. Create new node, set newNode->next = newNode, set head = newNode.

Solution

1. Step 1: Understand single node circular list

   The single node has head->next pointing to itself (head).

2. Step 2: Insert at end

   Set newNode->next = head->next (which is head), then head->next = newNode. This makes head -> newNode -> head, maintaining circularity without changing head.

3. Final Answer:

   Create new node, set newNode->next = head->next, set head->next = newNode. -> Option A

4. Quick Check:

   head -> newNode -> head [OK]

Hint: For single node circular: newNode->next = head->next; head->next = newNode [OK]

Common Mistakes:

• Setting newNode->next to NULL breaking circularity
• Unnecessarily updating head to newNode
• Incorrectly linking new node to itself