circular linked list&CLL（循环链表）

循环链表，和苯一样，一条蛇咬住了自己的尾巴。在 操作系统 给 进程 分配运行 资源 时，有体现。

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

struct node
{
    int data;
    struct node * next;
};
//插入动作，在头节点之前插入
void insert(struct node ** head_ref, int data)
{
    struct node * new_node = (struct node *) malloc (sizeof(struct node));
    struct node * temp = (*head_ref);
    new_node->data = data;
    // 头尾相连
    new_node->next = (*head_ref);
    //判断链表是否为空，如果不为空，则要循环到最后一个节点，让最后一个节点的next指向新的头结点
    if(NULL != (*head_ref))
    {
        while(temp->next != (*head_ref))
        {
            temp = temp->next;
        }
        temp->next = new_node;
    }
    else
    {
        //若链表为空链表，则将欲插入的节点的next指向他自己
        new_node->next = new_node;
    }
    //将其指定为头结点
    (*head_ref) = new_node;
}
//判断该链表是否为一个循环链表
int isCircular(struct node * head_ref)
{
    if(NULL == head_ref)
    {
        return 1;
    }

    struct node * temp = head_ref->next;

    while(temp != NULL && temp != head_ref)
    {
        temp = temp->next;
    }

    return (temp == head_ref) ? 1 : -1;
}
//打印循环链表，可以从任何一个位置打印，而单链表只能从头结点开始打印（不考虑位置关系的话）
void printCircularLinkedList(struct node * head_ref)
{
    struct node * temp = head_ref;

    if(NULL != head_ref)
    {
        do
        {
            printf("%d  ", temp->data);
            temp = temp->next;
        }
        while(temp != head_ref);
        printf("
");
    }
}
//手撕鬼子似的将循环链表撕裂，WOW，这里用到了单链表里返回链表中间元素的 方法之一
void splitList(struct node * head, struct node ** head1_ref, struct node ** head2_ref)
{
    struct node * fast_pointer = head;
    struct node * slow_pointer = head;

    if(-1 == headIsNULL(head))
    {
        printf("ERROR!");
        return ;
    }

    while(fast_pointer->next->next != head && fast_pointer->next != head)
    {
        fast_pointer = fast_pointer->next->next;
        slow_pointer = slow_pointer->next;
    }
    //如果不是当前元素不是尾节点的话，而是倒数第二个节点
    if(head == fast_pointer->next->next)
    {
        fast_pointer = fast_pointer->next;
    }
    //判断该链表是否只有一个节点
    if(head->next != head)
    {
        (*head2_ref) = slow_pointer->next;
        fast_pointer->next = slow_pointer->next;
    }
    (*head1_ref) = head;
    slow_pointer->next = (*head1_ref);
}
//排序式插入节点
void sortInsert(struct node ** head_ref, struct node * new_node)
{
    struct node * current = (*head_ref);

    if(NULL == (*head_ref))
    {
        new_node->next = new_node;
        (*head_ref) = new_node;
    }
    //如果插入节点的data小于当前头节点的data
    else if(current->data >= new_node->data)
    {
        while(current->next != (*head_ref))
            current = current->next;

        current->next = new_node;
        new_node->next = (*head_ref);
        (*head_ref) = new_node;
    }
    else
    {
        //若插入节点data大于当前节点data，循环链表到一个大于当前插入节点data的节点
        while(current->next != (*head_ref) && current->next->data < new_node->data)
        {
            current = current->next;
        }
        //新节点的next = 当前节点的下一个节点
        new_node->next = current->next;
        current->next = new_node;
    }
}
//判断链表是否为空
int headIsNULL(struct node * head_ref)
{
    return (NULL == head_ref)? -1 : 1;
}
int main(void)
{
    struct node * head = NULL;

    insert(&head, 0);
    insert(&head, 1);
    insert(&head, 3);
    insert(&head, 4);
    insert(&head, 5);
    printCircularLinkedList(head);
    struct node * firstList = NULL;
    struct node * lastList = NULL;
    splitList(head, &firstList, &lastList);
    printCircularLinkedList(firstList);
    printCircularLinkedList(lastList);
    /*------------------------------------*/
    int array[] = {2, 5, 1, 0, 9, 10, 3};
    int arraySize = sizeof(array)/sizeof(int);
    struct node * head_1 = NULL;
    struct node * temp = NULL;

    for(int i = 0; i < arraySize; i++)
    {
        temp = (struct node *) malloc (sizeof (struct node));
        temp->data = array[i];
        sortInsert(&head_1, temp);
    }
    printCircularLinkedList(head_1);
    if(0 < isCircular(head))
    {
        printf("
The linked list is circularLinked list!");
    }
    else
    {
        printf("
The linked list isn`t circularLinked list!");
    }
    return 0;
}

受益颇多