Circular Linked List – Explanation and Implementation

In a circular linked list all nodes are connected in a continuous cycle. Each node has two part Data and Next as a singly linked list has. The last node rather pointing to NULL, points to the first node, to which head points. As a result, the structure of the linked list looks like forming a loop, thus named as Circular Linked list.

It provides a way to traverse the list as many times as required. See the linked list shown, once element 50(last node) is traversed, pointer now reaches to the first node, therefore the list can be traversed again. Time taken in revisiting a node takes O(n). This is where a circular linked list lacks, the worst case is if needed to traverse the node just visited then it has to traverse the whole list again. Although it’s better than singly linked list but lacks backward traversing.

Circular Linked list
Circular LL

Read more – Linked List Types – Explanation


Implementation:

Implementation of a circular linked list is pretty similar to a singly linked list. The only change is how to get to the end of the list. Under singly linked list, it becomes NULL at the end but, for circular linked list traversing till Next starts pointing the head node. Therefore next of last node will contain address of first node(head of linked list).

head = firstNode;
lastNode->next = firstNode;

Implementation in C

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

//DECLARATION
struct node 
{
	int data;
	struct node *next;
};


// This function prints contents of linked list from given node
void printLinkedList(struct node *list)
{
	struct node *currentNode = list;
	
    do
    {
    	printf(" %d ", list->data);
    	list = list->next; // accessing and assigning the next element of list
    }while(list != currentNode);
}


// Main method to initialize the program
int main()
{
	//INITIALIZATION
    //Declare and allocate 3 nodes in the heap 
    struct node* head;
    struct node* first = (struct node*)malloc(sizeof(struct node)); 
    struct node* second = (struct node*)malloc(sizeof(struct node));
    struct node* third = (struct node*)malloc(sizeof(struct node));
    struct node* fourth = (struct node*)malloc(sizeof(struct node));
    
	//ASSIGNINMENT
    first->data = 10; //assign data in first node
    first->next = second; // Link first node with second 
    
    second->data = 20; //assign data to second node
    second->next = third; 
    
    third->data = 30; //assign data to third node
    third->next = fourth;

    fourth->data = 50; //assign data to fourth node
    fourth->next = first; // last node pointing to the first node

    head = first;    //head pointing to the linked list

   printLinkedList(head);
    
    return 0;
}

Output:-

10 20 30 50

Advantages of Circular linked list over singly linked list:

  • Circular linked list acts like a loop, any node can be the beginning node and traversing will be till the pointer reaches the same beginning node. Therefore Round robin fashion of access can be implemented. As a result, a large number of applications are there which can use circular linked list such as in Multi-player Games, Resource allocation in OS, etc. In short, it is widely used wherever the resource pooling is required.
  • Circular Doubly linked list results in better implementation of Queue, as there is no overhead of two variable needed to maintain (Front and Rear).
  • Any node can be made starting point as required.

Disadvantages

  • Backward traversing is not possible.
  • Insertion and Deletion takes O(n) in some cases.
  • Reversal Operation is same as in singly linked list, there is no better optimization here.

Knowledge is most useful when liberated and shared. Share this to motivate us to keep writing such online tutorials for free and do comment if anything is missing or wrong or you need any kind of help.
Keep Learning… Happy Learning.. :)