Insert at End of Circular Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting a node at the end of a circular linked list

What is the printed state of the circular linked list after inserting a node with value 4 at the end?

DSA C

/* Circular linked list node structure */
#include <stdio.h>
#include <stdlib.h>

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

/* Function to insert node at end */
void insertEnd(Node** head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    if (*head == NULL) {
        newNode->next = newNode;
        *head = newNode;
        return;
    }
    Node* temp = *head;
    while (temp->next != *head) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->next = *head;
}

/* Function to print list */
void printList(Node* head) {
    if (head == NULL) return;
    Node* temp = head;
    do {
        printf("%d -> ", temp->data);
        temp = temp->next;
    } while (temp != head);
    printf("null\n");
}

int main() {
    Node* head = NULL;
    insertEnd(&head, 1);
    insertEnd(&head, 2);
    insertEnd(&head, 3);
    insertEnd(&head, 4);
    printList(head);
    return 0;
}

A 4 -> 1 -> 2 -> 3 -> null

B 1 -> 2 -> 3 -> null

C 1 -> 2 -> 3 -> 4 -> null

D 1 -> 2 -> 3 -> 4

💡 Hint

Remember that in a circular linked list, the last node points back to the head, so printing stops when we reach the head again.

The insertEnd function adds the new node after the last node and points it back to the head. So the list becomes 1 -> 2 -> 3 -> 4 -> back to 1. The printList function prints nodes until it reaches the head again, so the output shows all four nodes followed by null.

❓ Predict Output

intermediate

Output after inserting into an empty circular linked list

What is the printed state of the circular linked list after inserting a node with value 10 into an empty list?

DSA C

/* Circular linked list node structure */
#include <stdio.h>
#include <stdlib.h>

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

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

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

int main() {
    Node* head = NULL;
    insertEnd(&head, 10);
    printList(head);
    return 0;
}

A null

B 10 -> null

C 10 -> 10 -> null

D Error: segmentation fault

💡 Hint

When the list is empty, the new node points to itself.

Since the list is empty, the new node's next points to itself, making a single-node circular list. The printList function prints the node once and then stops when it reaches the head again.

🔧 Debug

advanced

Identify the error in this insertEnd function for circular linked list

What error will this code cause when inserting a node at the end of a circular linked list?

DSA C

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

A Infinite loop because temp->next never becomes NULL in circular list

B Segmentation fault due to dereferencing NULL pointer

C Correct insertion with no errors

D Memory leak due to missing free

💡 Hint

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

The while loop condition checks for temp->next != NULL, but in a circular linked list, the last node's next points to head, never NULL. So the loop never ends, causing an infinite loop.

❓ Predict Output

advanced

Output after multiple insertions at end in circular linked list

What is the printed state of the circular linked list after these insertions: 5, 10, 15, 20?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

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

int main() {
    Node* head = NULL;
    insertEnd(&head, 5);
    insertEnd(&head, 10);
    insertEnd(&head, 15);
    insertEnd(&head, 20);
    printList(head);
    return 0;
}

A 5 -> 10 -> 15 -> 20

B 20 -> 15 -> 10 -> 5 -> null

C 5 -> 10 -> 15 -> null

D 5 -> 10 -> 15 -> 20 -> null

💡 Hint

Nodes are inserted at the end, so order is preserved.

Each new node is added after the last node and points back to head. The printList prints all nodes in insertion order followed by null.

🧠 Conceptual

expert

Why is the last node's next pointer important in a circular linked list?

What is the main reason the last node in a circular linked list points back to the head node?

A To make traversal continuous without needing a NULL check

B To mark the end of the list with a NULL pointer

C To store the size of the list in the last node

D To prevent insertion at the end of the list

💡 Hint

Think about how you know when to stop traversing a normal linked list.

In a circular linked list, the last node points back to the head to allow continuous traversal without encountering a NULL pointer. This makes the list circular and traversal can loop indefinitely.