Algorithm for Inserting in an Ordered Circular Linked List
1. Create a new node with the given data.
2. If the list is empty, make the new node point to itself and set it as the head.
3. If the new node should be inserted before the current head:
o Traverse to the last node.
o Adjust the last node’s next to point to the new node.
o The new node’s next should point to the current head.
o Update head to the new node.
4. Otherwise:
o Traverse the list to find the correct position where the new node should be inserted.
o Update pointers so the new node fits in the correct order.
C Code for Insertion in an Ordered Circular Linked List
#include <stdio.h>
#include <stdlib.h>
// Node structure
struct Node {
int data;
struct Node* next;
};
// Function to insert a node in an ordered circular linked list
void insertInOrder(struct Node** head, int data) {
// Create a new node
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
// If the list is empty
if (*head == NULL) {
newNode->next = newNode; // Points to itself
*head = newNode;
return;
struct Node* current = *head;
// If new node should be inserted before head
if (data < (*head)->data) {
// Find the last node
while (current->next != *head) {
current = current->next;
// Adjust pointers
current->next = newNode;
newNode->next = *head;
*head = newNode;
return;
// Traverse the list to find the correct position
struct Node* prev = NULL;
do {
prev = current;
current = current->next;
} while (current != *head && current->data < data);
// Insert the new node in its correct position
prev->next = newNode;
newNode->next = current;
// Function to display the Circular Linked List
void display(struct Node* head) {
if (head == NULL) {
printf("List is empty\n");
return;
struct Node* temp = head;
do {
printf("%d -> ", temp->data);
temp = temp->next;
} while (temp != head);
printf("(Head)\n");
// Main function
int main() {
struct Node* head = NULL;
// Insert elements in sorted order
insertInOrder(&head, 30);
insertInOrder(&head, 10);
insertInOrder(&head, 40);
insertInOrder(&head, 20);
insertInOrder(&head, 25);
// Display list
display(head);
return 0;
Explanation
1. Creating a new node
o Allocate memory using malloc.
o Assign the given value to data.
2. Handling the empty list case
o If the list is empty, make the new node’s next point to itself.
o Set head to this new node.
3. Inserting before the head (smallest element case)
o If the new value is smaller than the head’s data:
▪ Find the last node.
▪ Update the last node’s next to point to the new node.
▪ The new node’s next points to the old head.
▪ Update head to the new node.
4. Inserting in the middle or at the end
o Traverse to find the correct position.
o Update pointers to insert the new node at the correct spot.
Output
10 -> 20 -> 25 -> 30 -> 40 -> (Head)
This confirms that new elements are inserted in sorted order.
