C 循环链表

循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素

在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。

1） 普通插入元素（和单链表是一样的）

2） 尾插法（和单链表是一样的，单链表的写法支持尾插法；

因：辅助指针向后跳length次，指向最后面那个元素）

CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));

CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));

1） 头插法（要进行头插法，需要求出尾结点，和单链表不一样的地方，保证是循环链表）

第一次插入元素时，让游标指向0号结点

CircleList_Insert(list, (CircleListNode*)&v1, 0);

CircleList_Insert(list, (CircleListNode*)&v1, 0);

4)第一次插入元素

循环链表插入综合场景分析图

循环链表删除结点分析

1、 删除普通结点

2、 删除头结点（删除0号位置处元素），需要求出尾结点

优点：功能强了。

循环链表只是在单链表的基础上做了一个加强

循环链表可以完全取代单链表的使用

循环链表的Next和Current操作可以高效的遍历链表中的所有元素

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_
/*
typedef struct _tag_CircleListNode CircleListNode;
struct _tag_CircleListNode
{
    CircleListNode* next;
};
*/
typedef void T;

typedef struct _tag_CircleListNode
{
    struct _tag_CircleListNode * next;
}CircleListNode;

T* CircleList_Create();

void List_Destroy(T* list);

void CircleList_Clear(T* list);

int CircleList_Length(T* list);

int CircleList_Insert(T* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(T* list, int pos);

CircleListNode* CircleList_Delete(T* list, int pos);

//add

//根据结点的值 进行数据的删除
CircleListNode* CircleList_DeleteNode(T* list, CircleListNode* node);

CircleListNode* CircleList_Reset(T* list);

CircleListNode* CircleList_Current(T* list);

//游标指向2号位置
//把2号位置返回出来,同时让游标下移到3号位置
CircleListNode* CircleList_Next(T* list);

#endif

#include <stdio.h>
#include <malloc.h>
#include "CircleList.h"

typedef struct _tag_CircleList//循环链表结构体（头结点，游标，长度）
{
    CircleListNode header;//头结点
    CircleListNode* slider;//游标
    int length;
} TCircleList;

T* CircleList_Create() // O(1)初始化链表结构体
{
    TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
    if (ret == NULL)
    {
        return NULL;
    }

    ret->length = ;
    ret->header.next = NULL;
    ret->slider = NULL;
    return ret;
}

void CircleList_Destroy(T* list) // O(1)
{
    if (list == NULL)
    {
        return ;
    }
    free(list);
}

void CircleList_Clear(T* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    if (sList == NULL)
    {
        return ;
    }
    sList->length = ;
    sList->header.next = NULL;
    sList->slider = NULL;
}

int CircleList_Length(T* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    int ret = -;
    if (list == NULL)
    {
        return ret;
    }
    ret = sList->length;
    return ret;
}

int CircleList_Insert(T* list, CircleListNode* node, int pos) // O(n)
{
    int ret = , i=;
    TCircleList* sList = (TCircleList*)list;

    if (list == NULL || node== NULL || pos<)
    {
        return -;
    }

    CircleListNode* current = (CircleListNode*)sList;//头结点

    for(i=; (i<pos) && (current->next != NULL); i++)
    {
        current = current->next;
    }

    //current->next 0号节点的地址
    node->next = current->next; //
    current->next = node; //2

    //若第一次插入节点
    if( sList->length ==  )//这里游标一直指向第0号位置
    {
        sList->slider = node;
    }

    sList->length++;

    //若头插法 current仍然指向头部
    //（原因是：跳0步，没有跳走）
    if( current == (CircleListNode*)sList )
    {
        //获取最后一个元素
        CircleListNode* last = CircleList_Get(sList, sList->length - );
        last->next = current->next; //
    }

    return ret;
}

CircleListNode* CircleList_Get(T* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = ;

    if (list==NULL || pos<)
    {
        return NULL;
    }
    //if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )
    {
        CircleListNode* current = (CircleListNode*)sList;

        for(i=; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
    }

    return ret;
}

CircleListNode* CircleList_Delete(T* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = ;

    if( (sList != NULL) && (pos >= ) && (sList->length > ) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        CircleListNode* last = NULL;

        for(i=; i<pos; i++)
        {
            current = current->next;
        }

        //若删除第一个元素（头结点）
        if( current == (CircleListNode*)sList )
        {
            last = (CircleListNode*)CircleList_Get(sList, sList->length - );
        }

        //求要删除的元素
        ret = current->next;
        current->next = ret->next;

        sList->length--;

        //判断链表是否为空
        if( last != NULL )
        {
            sList->header.next = ret->next;
            last->next = ret->next;
        }

        //若删除的元素为游标所指的元素
        if( sList->slider == ret )
        {
            sList->slider = ret->next;
        }

        //若删除元素后，链表长度为0
        if( sList->length ==  )
        {
            sList->header.next = NULL;
            sList->slider = NULL;
        }
    }

    return ret;
}

CircleListNode* CircleList_DeleteNode(T* list, CircleListNode* node) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = ;

    if( sList != NULL )
    {
        CircleListNode* current = (CircleListNode*)sList;

        //查找node在循环链表中的位置i
        for(i=; i<sList->length; i++)
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }

            current = current->next;
        }

        //如果ret找到，根据i去删除
        if( ret != NULL )
        {
            CircleList_Delete(sList, i); //根据结点的值 求出结点的位置 ,根据位置删除元素
        }
    }

    return ret;
}

CircleListNode* CircleList_Reset(T* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;

    if( sList != NULL )
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }

    return ret;
}

CircleListNode* CircleList_Current(T* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;

    if( sList != NULL )
    {
        ret = sList->slider;
    }

    return ret;
}

//把当前位置返回，并且游标下移
//把当前游标所指的位置的元素返回出去
//游标下移
CircleListNode* CircleList_Next(T* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;

    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }

    return ret;
}

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

struct Value
{
    CircleListNode circlenode;
    int v;
};

int main11()
{
    CircleList* list = CircleList_Create();

    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    struct Value v6;
    struct Value v7;
    struct Value v8;

    int i = ;

    v1.v = ;
    v2.v = ;
    v3.v = ;
    v4.v = ;
    v5.v = ;
    v6.v = ;
    v7.v = ;
    v8.v = ;

    CircleList_Insert(list, (CircleListNode*)&v1, );
    CircleList_Insert(list, (CircleListNode*)&v2, );
    CircleList_Insert(list, (CircleListNode*)&v3, );
    CircleList_Insert(list, (CircleListNode*)&v4, );

    for(i=; i<*CircleList_Length(list); i++) //怎么样证明是循环链表
    {
        struct Value* pv = (struct Value*)CircleList_Get(list, i);

        printf("%d\n", pv->v);
    }

    while( CircleList_Length(list) >  )
    {
        CircleList_Delete(list, );
    }

    printf("\n");

    CircleList_Destroy(list);

    system("pause");

    return ;
}

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

struct Value
{
    CircleListNode header;
    int v;
};

void  main()
{
    int i = ;
    CircleList* list = CircleList_Create();

    struct Value v1, v2, v3, v4, v5, v6, v7, v8;

    v1.v = ;    v2.v = ;    v3.v = ;    v4.v = ;
    v5.v = ;    v6.v = ;    v7.v = ;    v8.v = ;

    CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));

    for(i=; i<CircleList_Length(list); i++)
    {
        //获取游标所指元素,然后游标下移
        struct Value* pv = (struct Value*)CircleList_Next(list);
        printf("%d ", pv->v);
    }

    printf("\n");

    //重置游标
    CircleList_Reset(list);

    while( CircleList_Length(list) >  )
    {
        struct Value* pv = NULL;
        for(i=; i<; i++)
        {
            CircleList_Next(list);
        }
        pv = (struct Value*)CircleList_Current(list);
        printf("%d ", pv->v);
        CircleList_DeleteNode(list, (CircleListNode*)pv); //根据结点的值,进行结点元素的删除
    }

    CircleList_Destroy(list);

    system("pause");
    return ;
}