1.单向循环链表

单向循环链表与单向链表的的区别在于，单向链表的的最后一个结点的指针域next指向的NULL，而单向循环链表的最后一个结点的指针域重新指向了它的首元结点。如下图所示：

单向循环链表单向链表

2.循环链表初始化以及赋值

单向循环链表的创建分为两种情况：
第一种情况：第一次创建;
第二种情况：链表已经创建成功，并且已经存储了相应的结点，需要在链表的末尾继续新增数据。

/*
 2种情况:① 第一次开始创建; ②已经创建,往里面新增数据
 
 1. 判断是否第一次创建链表
    YES->创建一个新结点,并使得新结点的next 指向自身; (*L)->next = (*L);
    NO-> 找链表尾结点,将尾结点的next = 新结点. 新结点的next = (*L);
 */
Status CreateList(LinkList *L){

    int item;
    LinkList temp = NULL;
    LinkList r = NULL;//临时指针 用来来记录最后一个结点
    printf("输入节点的值，输入0结束\n");
    while(1)
    {
        scanf("%d",&item);
        if(item==0) break;
        
          //如果输入的链表是空。则创建一个新的节点，使其next指针指向自己  (*head)->next=*head;
        if(*L==NULL)
        {
           *L = (LinkList)malloc(sizeof(Node));
            if(!*L) return ERROR;
            (*L)->data = item;
            (*L)->next = *L;
            r = *L;
        }
        else
        {
            //输入的链表不是空的
            temp = (LinkList)malloc(sizeof(Node));
            if(!temp) return  ERROR;
            temp->data = item;
            temp->next = *L;//新节点指向头节点
            r->next = temp;//尾节点指向新节点，新节点成为尾结点
            
            r = temp;//r指向新的尾结点
        }
    }
    
    return OK;
}

3.循环链表插入数据

一个单向循环链表中插入数据,需要分析2种情况:
第一种情况,则是插入的位置在首元结点上;
第二种情况,插入其他位置(包括链表中间/末尾);

3.1.插入位置在首元节点上

先创建新节点temp,将temp的指针域next指向首元结点；再找到尾结点，将尾结点的next指向temp;最后将L指向temp，temp成为首元结点。

3.2.插入位置在其他位置

先创建新节点temp,并它赋值；再找到插入位置的目标结点target; 将target的next赋值给temp的next;最后target的next指向temp。插入的代码实现如下：

Status ListInsert(LinkList *L, int place, int num){
    
    LinkList temp ,target;
    int i;
    if (place == 1) {
        
        //如果插入的位置为1,则属于插入首元结点,所以需要特殊处理
        //1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
        //2. 找到链表最后的结点_尾结点,
        //3. 让新结点的next 执行头结点.
        //4. 尾结点的next 指向新的头结点;
        //5. 让头指针指向temp(临时的新结点)
        
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        
        for (target = *L; target->next != *L; target = target->next);
        
        temp->next = *L;
        target->next = temp;
        *L = temp;
        
    }else
    {
        
        //如果插入的位置在其他位置;
        //1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
        //2. 先找到插入的位置,如果超过链表长度,则自动插入队尾;
        //3. 通过target找到要插入位置的前一个结点, 让target->next = temp;
        //4. 插入结点的前驱指向新结点,新结点的next 指向target原来的next位置 ;
        
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        
        for ( i = 1,target = *L; target->next != *L && i != place - 1; target = target->next,i++) ;
        
        temp->next = target->next;
        target->next = temp;
    }
    
    return OK;
}

4.循环链表删除数据

一个单向循环链表中删除数据,需要分析2种情况:
第一种情况,则是删除的位置在首元结点上; 如果这时链表上只有一个首元结点，直接将链表指针置为空。如果这时链表仍有多个结点，则找到尾结点target, 将target的next指向首元结点的next，最后释放首元结点第二种情况,删除其他位置(包括链表中间/末尾)；找到要删除位置的前一个结点target，将target的next指向要被删除的结点temp的next，使链表重新连接起来。最后释放temp 代码实现如下:

Status  LinkListDelete(LinkList *L,int place){
    
    LinkList temp,target;
    int i;
    //temp 指向链表首元结点
    temp = *L;
    //如果此时链表为空 直接返回ERROR
    if(temp == NULL) return ERROR;
    
    if (place == 1) {
        //1 如果链表只剩下首元结点了,则直接将*L置空;
        if((*L)->next == (*L)){
            (*L) = NULL;
            return OK;
        }
        
        //2 链表还有很多数据,但是删除的是首结点;
        //找到尾结点target, 
        for (target = *L; target->next != *L; target = target->next);
        
        //首元结点的next做为新的头结点
        *L = (*L)->next;
        //使尾结点的next指向新的头结点 
        target->next = *L;
        
        //释放原来的头结点
        free(temp);
    }else
    {
        
        //如果删除其他结点--其他结点
        //找到删除结点前一个结点target
        for(i=1,target = *L;target->next != *L && i != place -1;target = target->next,i++) ;
        
        //temp即为要被删除的结点
        temp = target->next;
        //使target的next指向temp的next, 跳过temp将链表重新链接起来
        target->next = temp->next;
        
        //3. 释放需要删除的结点temp
        free(temp);
    }
    
    return OK;
}

数据结构与算法——单向循环链表