C Data Structures - Circular Singly Linked List Other Related Topics

C - Circular Singly Linked List



A circular singly linked list is a linear data structure, in which the elements are stored in the form of a node. Each node contains two sub-elements. A data part that stores the value of the element and the next part that stores the pointer to the next node as shown in the below image:

Linked List Node

The first node also known as HEAD is always used as a reference to traverse the list. The last node points to HEAD. A circular singly linked list can be visualized as a chain of nodes, where every node points to the next node. Along with this, next of the last node is linked to the head node.

Linked List

Implementation of Circular Singly Linked List

Representation:

In C, a node can be created using structure as shown below:

//node structure
struct Node {
  int data;
  struct Node* next;
};

Create a Circular Singly Linked List

Let us create a simple circular singly linked list which contains three data nodes.

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

//node structure
struct Node {
  int data;
  struct Node* next;
};

// test the code  
int main() {
  //create the head node with name MyList
  struct Node* MyList = NULL;

  //Add first node.
  struct Node* first;
  //allocate second node in the heap
  first = (struct Node*)malloc(sizeof(struct Node));  
  first->data = 10;
  //linking with head node
  MyList = first; 
  //linking next of the node with head
  first->next = MyList;

  //Add second node.
  struct Node* second;
  //allocate second node in the heap
  second = (struct Node*)malloc(sizeof(struct Node));  
  second->data = 20;
  //linking with first node
  first->next = second;
  //linking next of the node with head
  second->next = MyList;

  //Add third node.
  struct Node* third;
  //allocate third node in the heap
  third = (struct Node*)malloc(sizeof(struct Node));  
  third->data = 30;
  //linking with second node
  second->next = third; 
  //linking next of the node with head
  third->next = MyList;

  return 0; 
}

Traverse a Circular Singly Linked List

A circular singly linked list can be traversed from any node of the list using a temp node. Keep on moving the temp node to the next one and displaying its content. Stop the traversal, after reaching the starting node.

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

//node structure
struct Node {
  int data;
  struct Node* next;
};

//display the content of the list
void PrintList(struct Node* head_ref) {
  struct Node* temp = head_ref;
  if(head_ref != NULL) {
    printf("The list contains: ");
    while (1) {
      printf("%i ",temp->data);
      temp = temp->next;
      if(temp == head_ref)
        break;    
    }
    printf("\n");
  } else {
    printf("The list is empty.\n");
  }   
}

// test the code  
int main() {
  //create the head node with name MyList
  struct Node* MyList = NULL;

  //Add first node.
  struct Node* first;
  //allocate second node in the heap
  first = (struct Node*)malloc(sizeof(struct Node));  
  first->data = 10;
  //linking with head node
  MyList = first; 
  //linking next of the node with head
  first->next = MyList;

  //Add second node.
  struct Node* second;
  //allocate second node in the heap
  second = (struct Node*)malloc(sizeof(struct Node));  
  second->data = 20;
  //linking with first node
  first->next = second;
  //linking next of the node with head
  second->next = MyList;

  //Add third node.
  struct Node* third;
  //allocate third node in the heap
  third = (struct Node*)malloc(sizeof(struct Node));  
  third->data = 30;
  //linking with second node
  second->next = third; 
  //linking next of the node with head
  third->next = MyList;

  //print the content of list
  PrintList(MyList);
  return 0; 
}

The above code will give the following output:

The list contains: 10 20 30

5