1. Definition: circular linked list is a kind of linked list which has no head and tail, but in order to provide access to the linked list and facilitate the operation of the linked list, "head" and "tail" are defined
2. Circular list can be realized by simple addition and modification on one-way list, but it is realized separately here.
3. For example, when scheduling tasks in the operating system, tasks with the same priority will get the same CPU usage right at the same time. After one task occupies the CPU, it is necessary to give up the CPU to the next task. In this way, the circular list can be used.

Here is the C + + Code:

#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;

 //Node class of linked list
class Node{
	public:
	int value;	//Node data
	Node* next;	//Reference to next node
	
	//Constructor
	Node(int aValue, Node* aNext=0){
		value = aValue;
		next = aNext;
	}
}; 

//Circular list class
class CircularLinkedList{
	public:
		Node* head;		//Head node of linked list
						//Although there is no head and tail in the theory of circular list, but the list needs an entry, and in order to modify the list conveniently, there are assumed head and tail
		Node* tail;		//Tail node of linked list
		int length;		//Length of linked list
	
	//Constructor
	CircularLinkedList(){
		head = 0;
		tail = 0;
		length = 0;
	}

	//Judge whether the list is empty
	int isEmpty(){
		return head==0;
	}
	

	//Determine whether the linked list contains an element
	int contains(int value){
		//Search by traversing the linked list
		for (Node* now=head; now->next!=head; now=now->next)
			if(now->value == value)
				return true;
		return false;
	}
	
	//Add node to head
	void addToHead(int value){
		Node* tmp = new Node(value);
		//If the list is empty, update the head and tail
		if(head == 0){
			tmp->next = tmp;
			head = tail = tmp;
		}
		//Otherwise, only the head will be updated
		else{
			tmp->next = head;
			tail->next = tmp;	
			head = tmp;			
		}
		length++;
	}


	//Add node to tail
	void addToTail(int value){
		Node* tmp = new Node(value);
		//If the list is empty, update the head and tail
		if (head==0){
			tmp->next = tmp;
			head = tail = tmp;
		}
		//Otherwise, only tail will be updated
		else {
			tmp->next = head;
			tail->next = tmp;	
			tail = tmp;	
		}
		length++;
	}

	//Add a node to the specified subscript location starting from the beginning of the node. The subscript starts at 1 and ends at length
	void addNode(int value, int index){
		//Illegal subscript, direct return
		if (index<=0 || index>length+1)
			return ;
		
		//If the list is empty, add a node to the location (addToHead should be called directly here)
		if (head==0 && index==1){
			Node* tmp = new Node(value);
			tmp->next = tmp;
			head = tail = tmp;
		}	
		//If you add a node to the chain header, call addToHead
		else if (index==1){
			addToHead(value);
		}
		//If you append a node to the end of the list, call addToTail
		else if (index==length+1)
			addToTail(value);
		//Otherwise, add nodes to the middle of the list
		else{
			//Counter for counting to
			int cnt=0;
			//Newly created node
			Node* tmp = new Node(value);
			//To add the previous node of a node
			Node* aheadOfAdd=0;
			//Loop to find the previous node to add a node
			for (cnt=1,aheadOfAdd=head; cnt+1<index; aheadOfAdd=aheadOfAdd->next,cnt++);
			//Add node
			tmp->next = aheadOfAdd->next;
			aheadOfAdd->next = tmp;
			length++;
		}
	}

	//Delete node from head
	int deleteFromHead(){
		//The linked list is empty. It can't be deleted any more. Return directly
		if(head==0)
			return -1;
		//Deleted nodes and deleted values
		Node* deletedNode=0;
		int deletedValue=0;
		//If there is only one node, delete it directly, and update the head and tail to be empty
		if (head==tail){
			deletedNode = head;
			head = tail = 0;
		}
		//Otherwise, it will be deleted normally
		else{
			deletedNode = head;
			tail->next = head->next;
			head = head->next;
		}
		length--;
		deletedValue = deletedNode->value;
		delete deletedNode;
		return deletedValue;
	}

	//Delete a node from the end of the list
	int deleteFromTail(){
		//The linked list is empty. It can't be deleted any more. Return directly
		if(head==0)
			return -1;
		//Deleted nodes and deleted values
		Node* deletedNode=0;
		int deletedValue=0;
		//If there is only one node, delete it directly, and update the head and tail to be empty
		if (head==tail){
			deletedNode = tail;
			head = tail = 0;
		}
		//Otherwise, it will be deleted normally
		else{
			int cnt=0;
			Node* aheadOfDelete = 0;
			for(aheadOfDelete=head; aheadOfDelete->next!=tail; aheadOfDelete=aheadOfDelete->next);
			deletedNode = aheadOfDelete->next;
			aheadOfDelete->next = head;
			tail = aheadOfDelete;	
		}
		length--;
		
		deletedValue = deletedNode->value;
		delete deletedNode;
		return deletedValue;
	}

	//Delete node according to given subscript
	int deleteNode(int index){
		//If the subscript is illegal or the list is empty, return directly
		if (index<0 || index>length || head==0)
			return -1;	

		//To delete the first node, call deleteFromHead
		if (index==1)
			return deleteFromHead();
		//The linked list has only one node, but the subscript is not 1. It is returned directly
		else if(head == tail && index!=-1)
			return -1;
		//If you want to delete the tail node, call deleteFromTail directly
		else if(index==length)
			return deleteFromTail();
		//Other circumstances
		else{
			//Counter, used to count the previous node to find the node to delete
			int cnt=0;
			//The previous node of the node to delete
			Node* aheadOfDelete=0;
			//Loop to find the node
			for(cnt=1,aheadOfDelete=head; cnt+1<index; aheadOfDelete=aheadOfDelete->next,cnt++);
			//Nodes to delete and corresponding values
			Node* deletedNode = aheadOfDelete->next;
			int deletedValue = deletedNode->value;
			//Delete this node
			aheadOfDelete->next = deletedNode->next;
			length--;
			delete deletedNode;
			return deletedValue;
		}
	}	

	//Print the contents of the linked list. Because it is a circular linked list, print the value of the next node according to tail - > next, and verify whether the circular structure is correct
	void printSelf(){
		int cnt=0;
		Node* now=0;
		printf("CircularLinkedList: [");
		for (now=head,cnt=1; cnt<=length; cnt++,now=now->next)
			printf("%d, ", now->value);
		
		printf("]\n");	
		if (!isEmpty())
			printf("\t\ttail->next: %d\tlength: %d %d\n", tail->next->value, length, isEmpty());
		else 
			printf("\t\tEmpty CircularLinkedList\n");
	}
};

//Test function
int main(){
	CircularLinkedList* list = new CircularLinkedList();
	list->addToHead(123);list->printSelf();
	list->addToHead(124);list->printSelf();
	list->addToHead(125);list->printSelf();
	list->addToTail(1);list->printSelf();
	list->addToTail(2);list->printSelf();
	list->addToTail(3);list->printSelf();
	list->addNode(10000,1);list->printSelf();
	list->addNode(10001,2);list->printSelf();
	list->addNode(10005,9);list->printSelf();
	printf("deletedValue: %d\n", list->deleteNode(9));list->printSelf();
	//list->deleteFromHead();list->printSelf();
	printf("deleting!\n");
	//while(!list->isEmpty()){
	//	list->deleteFromTail();list->printSelf();
	//}
}