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

Insert at Beginning of Circular Linked List

📖 Scenario: You are managing a circular linked list that represents a playlist of songs. Each node contains the song's ID. You want to add a new song at the beginning of the playlist so it plays next.

🎯 Goal: Build a program in C that creates a circular linked list, then inserts a new node at the beginning, and finally prints the updated list.

📋 What You'll Learn

Define a struct Node with an int data and a struct Node* next pointer.

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

Add a function to insert a new node with data 5 at the beginning of the circular linked list.

Print the circular linked list starting from the head node after insertion.

💡 Why This Matters

🌍 Real World

Circular linked lists are used in applications like music playlists, round-robin scheduling, and buffering where the list loops back to the start.

💼 Career

Understanding circular linked lists helps in system programming, embedded systems, and designing efficient data structures for real-time applications.

1

Create the initial circular linked list

Define a struct Node with int data and struct Node* next. Then create three nodes with data 10, 20, and 30 linked in a circular way. Store the head pointer in 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 function to insert at the beginning

Write a function called insertAtBeginning that takes struct Node** head and int data as parameters. This function should create a new node with the given data and insert it at the beginning of the circular linked list, updating the head pointer.

DSA C

#include 
#include 

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

// Write insertAtBeginning function here
// Your code here

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 = 10;
    head->next = second;

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

    third->data = 30;
    third->next = head; // circular link

    return 0;
}

Hint

To insert at the beginning, find the last node to update its next pointer to the new node, then update head.

3

Call the insert function to add new node

In main, call insertAtBeginning with &head and 5 to insert a new node with data 5 at the beginning of the circular linked list.

DSA C

#include 
#include 

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

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

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

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

    newNode->next = *head;
    temp->next = newNode;
    *head = newNode;
}

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 = 10;
    head->next = second;

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

    third->data = 30;
    third->next = head; // circular link

    // Call insertAtBeginning to add node with data 5
    // Your code here

    return 0;
}

Hint

Call insertAtBeginning with the address of head and the value 5.

4

Print the circular linked list

Write a function called printList that takes struct Node* head and prints the data of each node in the circular linked list separated by ->. Then call printList(head) in main after insertion.

DSA C

#include 
#include 

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

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

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

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

    newNode->next = *head;
    temp->next = newNode;
    *head = newNode;
}

// Write printList function here
// Your code here

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 = 10;
    head->next = second;

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

    third->data = 30;
    third->next = head; // circular link

    insertAtBeginning(&head, 5);

    // Call printList to display the list
    // Your code here

    return 0;
}

Hint

Use a do-while loop to print nodes until you reach the head again.

Practice

1. What happens when you insert a new node at the beginning of a circular linked list?

easy

A. The new node is added at the end of the list, breaking the circular link.

B. The new node becomes the head and points to the old head, maintaining the circular link.

C. The new node replaces the last node in the list.

D. The list becomes a linear linked list instead of circular.

Solution

1. Step 1: Understand the circular linked list structure

   A circular linked list has its last node pointing back to the head node, forming a circle.

2. Step 2: Insert new node at beginning

   The new node is linked to the current head, and the last node's next pointer is updated to this new node, making it the new head.

3. Final Answer:

   The new node becomes the head and points to the old head, maintaining the circular link. -> Option B

4. Quick Check:

   New head points to old head, circle intact [OK]

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

Common Mistakes:

• Forgetting to update last node's next pointer
• Breaking the circular link by not connecting last node
• Replacing the last node instead of adding new head

2. Which of the following is the correct syntax to create a new node and insert it at the beginning of a circular linked list in C?

easy

A. head = new_node; new_node->next = head; last->next = head;

B. head = new_node; new_node->next = last; last = head;

C. last->next = new_node; new_node->next = head; head = new_node;

D. new_node->next = NULL; head = new_node; last->next = NULL;

Solution

1. Step 1: Link new node to current head

   Set new_node->next to head so new node points to old first node.

2. Step 2: Update last node's next pointer and head

   Set last->next to new_node to maintain circular link, then update head to new_node.

3. Final Answer:

   last->next = new_node; new_node->next = head; head = new_node; -> Option C

4. Quick Check:

   New node links head and last points to new node [OK]

Hint: Link new node between last and head, then update head [OK]

Common Mistakes:

• Setting new_node->next to NULL breaks circular link
• Updating head before linking last node
• Confusing order of pointer assignments

3. What will be the output of the following code snippet after inserting 10 at the beginning of the circular linked list?

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

// Existing list: 20 -> 30 -> 40 -> back to 20
struct Node* head = node20;
struct Node* last = node40;

// Insert 10 at beginning
struct Node* new_node = malloc(sizeof(struct Node));
new_node->data = 10;
new_node->next = head;
last->next = new_node;
head = new_node;

// Print list starting from head (print 4 nodes)

medium

A. 10 -> 20 -> 30 -> 40 -> back to 10

B. 20 -> 30 -> 40 -> 10 -> back to 20

C. 10 -> 30 -> 40 -> 20 -> back to 10

D. 30 -> 40 -> 20 -> 10 -> back to 30

Solution

1. Step 1: Insert new node at beginning

   New node with data 10 points to old head (20), last node (40) points to new node, head updated to new node.

2. Step 2: Print nodes starting from new head

   Printing 4 nodes from head: 10, 20, 30, 40, then back to 10.

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> back to 10 -> Option A

4. Quick Check:

   New head 10 followed by old nodes in order [OK]

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

Common Mistakes:

• Not updating last->next to new node
• Printing old head as start
• Mixing node order after insertion

4. Identify the error in the following code that inserts a node at the beginning of a circular linked list:

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

medium

A. The head pointer is not updated to new node.

B. The new node's data is not assigned correctly.

C. Memory allocation is missing for new node.

D. The last node's next pointer is not updated to new head, breaking circular link.

Solution

1. Step 1: Check pointer updates

   The code updates head to new node and new node points to old head, but does not update last node's next pointer.

2. Step 2: Understand circular link maintenance

   In circular linked list, last node must point to new head to keep circle intact; missing here causes broken link.

3. Final Answer:

   The last node's next pointer is not updated to new head, breaking circular link. -> Option D

4. Quick Check:

   Last node must point to new head [OK]

Hint: Always update last node's next to new head [OK]

Common Mistakes:

• Ignoring last node pointer update
• Assuming head update is enough
• Not handling empty list case

5. You have a circular linked list with nodes: 5 -> 15 -> 25 -> back to 5. You want to insert 1 at the beginning. Which sequence of pointer updates correctly maintains the circular linked list?

hard

A. Create new node with 1, set last->next = new_node, new_node->next = head, head = new_node.

B. Create new node with 1, set head = new_node, new_node->next = head, update last->next = new_node.

C. Create new node with 1, set new_node->next = NULL, head = new_node, last->next = head.

D. Create new node with 1, set head = new_node, new_node->next = last, last->next = head.

Solution

1. Step 1: Link new node between last and head

   Set last->next to new node, then new_node->next to old head to maintain circle.

2. Step 2: Update head pointer

   Set head to new node so it becomes the first node in the list.

3. Final Answer:

   Create new node with 1, set last->next = new_node, new_node->next = head, head = new_node. -> Option A

4. Quick Check:

   Last points new node, new node points old head, head updated [OK]

Hint: Last points new node, new node points old head, update head last [OK]

Common Mistakes:

• Setting new_node->next to NULL breaks circle
• Updating head before linking last node
• Confusing pointer order causing broken links