# 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:

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.

## 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;

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

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;

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;
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;

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

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;

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