循环链表c语言实现 circlelinklist.h 和 circlelinklist.c

circlelinklist.h 文件

#ifndef _CIRCLE_LINK_LIST_H_
#define _CIRCLE_LINK_LIST_H_
#include 
#include 
#include 
//循环链表
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。
//链表就是一个一个的表通过关系节点连接的


//利用小节点定义一个链表头，其他的业务节点有业务自己定义后连接到表头上

//实现上层调用和底层分离，不让调用用户知道数据结构
typedef void List;
typedef void ListNode;

#ifndef bool
#define bool int
#define true 1
#define false 0
#endif

//定义小节点是有联系的 ,小节点的链表
typedef struct _tag_CircleLinkListConnectedNode
{
    struct _tag_CircleLinkListConnectedNode* next;
}CircleLinkListConnectedNode;

//定义链表
typedef struct _tag_CircleLinkList{
    CircleLinkListConnectedNode head;  //小节点
    CircleLinkListConnectedNode* slider; //游标 
    int length; //小节点的个数就相当于业务节点的个数
}CircleLinkList;


List* CircleLinkList_Create();
bool CircleLinkList_Destory(List* list);
bool CircleLinkList_Clear(List* list);
int CircleLinkList_GetLength(List* list);
bool CircleLinkList_InsertOneNode(List* list , ListNode* listnode, int pos);
ListNode* CircleLinkList_GetOneNode(List* list, int pos);
ListNode* CircleLinkList_DeleteOneNode(List* list,int pos);
bool CircleLinkList_DeleteAllNode(List* list);
ListNode* CircleLinkList_DeleteOneNodeByNodePointer(List* list,ListNode* listnode);
ListNode* CircleLinkList_ResetSlider(List* list);
ListNode* CircleLinkList_GetCurrentSlider(List* list);
ListNode* CircleLinkList_SliderMoveToNext(List* list);
#endif

circlelinklist.c 文件

#include 
#include 
#include 
#include "circlelinklist.h"
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。
//链表就是一个一个的表通过关系节点连接的
List* CircleLinkList_Create()
{
   List* ret = NULL;
   CircleLinkList* temp_circlelist = NULL;
   temp_circlelist = (CircleLinkList*)malloc(sizeof(CircleLinkList));
   if (temp_circlelist == NULL)
   {
       return NULL;
   }
   temp_circlelist->head.next =NULL;
   temp_circlelist->length = 0;
   temp_circlelist->slider = NULL;
   ret = (CircleLinkList*)temp_circlelist;
   return ret;
}

bool CircleLinkList_Destory(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_circlelist = (CircleLinkList*)list;
    free(temp_circlelist);
    temp_circlelist = NULL;
    return true;
}

bool CircleLinkList_Clear(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_circlelist = (CircleLinkList*)list;
    //长度清零，头部指向空，游标指向空
    temp_circlelist->length = 0;
    temp_circlelist->head.next = NULL;
    temp_circlelist->slider = NULL;
    return true;
}

int CircleLinkList_GetLength(List* list)
{
    int ret = 0;
    CircleLinkList* temp_circlelist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    temp_circlelist = (CircleLinkList*)list;
    ret = temp_circlelist->length;
    return ret;
}

bool CircleLinkList_InsertOneNode(List* list , ListNode* listnode, int pos)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node = NULL;
    CircleLinkListConnectedNode* pcurrent = NULL;
    int i = 0;
    CircleLinkListConnectedNode* lastnode = NULL;
    if (list == NULL || listnode == NULL || pos < 0)
    {
        return false;
    }
    temp_circlelist = (CircleLinkList*)list;
    temp_circlelistconnected_node = (CircleLinkListConnectedNode*)listnode;
    //链表的首地址与小节点的地址相同
    pcurrent = (CircleLinkListConnectedNode*)temp_circlelist;
    //pcurrent =(CircleListNode*) &(temp_circlelist->head);
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for (i = 0; (i < pos && pcurrent->next != NULL); i ++)
    {
        pcurrent = pcurrent->next;
    }
    //插入节点
    temp_circlelistconnected_node->next = pcurrent->next;
    pcurrent->next = temp_circlelistconnected_node;
    //第一次插入节点，游标指向插入的第一个节点 即 0 位置
    if (temp_circlelist->length == 0)
    {
        temp_circlelist->slider = temp_circlelistconnected_node;
    }
    //长度加1
    temp_circlelist->length++;
    //辅助指针没有调，头插法,插到0位置
    if (pcurrent == (CircleLinkListConnectedNode*)temp_circlelist)
    {
        //得到最后一个节点
        lastnode = (CircleLinkListConnectedNode*)CircleLinkList_GetOneNode((List*)temp_circlelist,temp_circlelist->length - 1);
        //最后一个节点的next域指向当前插入
        lastnode->next = pcurrent->next;
        //lastnode->next = temp_circlelist_node;
    }
    return true;
}

ListNode* CircleLinkList_GetOneNode(List* list, int pos)
{

    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node = NULL;
    CircleLinkListConnectedNode* pcurrent = NULL;
    int i = 0;
    ListNode* ret = NULL;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;
    //不要判断长度了，循环的嘛
    if (temp_circlelist->length <= 0 )
    {
        return NULL;
    }
    //链表的首地址与小节点的地址相同
    pcurrent = (CircleLinkListConnectedNode*)temp_circlelist;
    //pcurrent =(CircleListNode*) &(temp_circlelist->head);
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for (i = 0; (i < pos && pcurrent->next != NULL); i ++)
    {
        pcurrent = pcurrent->next;
    }
    temp_circlelistconnected_node = (CircleLinkListConnectedNode*)(pcurrent->next);
    ret = (ListNode*)temp_circlelistconnected_node;
    return ret;
}

ListNode* CircleLinkList_DeleteOneNode(List* list,int pos)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node_delete = NULL;
    CircleLinkListConnectedNode* pcurrent = NULL;
    CircleLinkListConnectedNode* lastnode = NULL;
    int i = 0;
    ListNode* ret = NULL;
    if (list == NULL || pos < 0) 
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;
    //链表的首地址与小节点的地址相同
    pcurrent = (CircleLinkListConnectedNode*)temp_circlelist;
    //pcurrent =(CircleListNode*) &(temp_circlelist->head);
    if (temp_circlelist->length <= 0 || pos >= temp_circlelist->length)
    {
        return NULL;
    }
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for (i = 0; (i < pos && pcurrent->next != NULL); i ++)
    {
        pcurrent = pcurrent->next;
    }
    temp_circlelistconnected_node_delete = pcurrent->next;
    pcurrent->next = temp_circlelistconnected_node_delete->next;
    //pcurrent->next = pcurrent->next->next;
    //如果从0位置删除
    if (pcurrent == (CircleLinkListConnectedNode*)temp_circlelist)
    {
        //得到最后一个节点
        lastnode = (CircleLinkListConnectedNode*)CircleLinkList_GetOneNode((List*)temp_circlelist,temp_circlelist->length - 1);
        //最后一个节点的next域指向当前插入
        if (lastnode != NULL)
        {
            lastnode->next = pcurrent->next;
            //lastnode->next = temp_circlelist_node_delete->next;
            //lastnode->next = temp_circlelist->head.next;
        }

    }
    //长度减1
    temp_circlelist->length--;
    //如果删除的是游标指向的位置则游标下移
    if (temp_circlelist->slider == temp_circlelistconnected_node_delete)
    {
        temp_circlelist->slider = temp_circlelistconnected_node_delete->next;
    }
    //长度为0就清空
    if (temp_circlelist->length == 0)
    {
        temp_circlelist->head.next = NULL;
        temp_circlelist->slider = NULL;
    }

    ret = (ListNode*)temp_circlelistconnected_node_delete;
    return ret;
}

bool CircleLinkList_DeleteAllNode(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_circlelist = (CircleLinkList*)list;
    while (temp_circlelist->length > 0 )
    {
        CircleLinkList_DeleteOneNode((List*)temp_circlelist,0);
    }
    return true;
}

ListNode* CircleLinkList_DeleteOneNodeByNodePointer(List* list,ListNode* listnode)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node_delete = NULL;
    CircleLinkListConnectedNode* pcurrent = NULL;
    CircleLinkListConnectedNode* retnode = NULL;
    int i = 0;
    ListNode* ret = NULL;
    if (list == NULL || listnode == NULL)
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;
    temp_circlelistconnected_node_delete = (CircleLinkListConnectedNode*)listnode;
    pcurrent = (CircleLinkListConnectedNode*)temp_circlelist;
    for (i = 0; i < temp_circlelist->length; i ++)
    {
        pcurrent = pcurrent->next;
        if (pcurrent == temp_circlelistconnected_node_delete)
        { 
            retnode = pcurrent;
            break;
        }
    }
    if (retnode == NULL)
    {
        return NULL;
    }
    CircleLinkList_DeleteOneNode((List*)temp_circlelist,i);
    ret =(ListNode*)retnode;
    return ret;
}

//重置游标
ListNode* CircleLinkList_ResetSlider(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;
    temp_circlelist->slider = temp_circlelist->head.next;

    temp_circlelistconnected_node = temp_circlelist->slider;
    ret = (ListNode* )temp_circlelistconnected_node;
    return ret;
}
//返回当前游标，
ListNode* CircleLinkList_GetCurrentSlider(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;

    temp_circlelistconnected_node = temp_circlelist->slider;
    ret = (ListNode* )temp_circlelistconnected_node;
    return ret;
}
//游标下移，并返回游标下移之前的节点
ListNode* CircleLinkList_SliderMoveToNext(List* list)
{
    CircleLinkList* temp_circlelist = NULL;
    CircleLinkListConnectedNode* temp_circlelistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_circlelist = (CircleLinkList*)list;
    if (temp_circlelist->slider == NULL)
    {
        return NULL;
    }
    //得到当前游标指向的节点
    temp_circlelistconnected_node = temp_circlelist->slider;
    //游标下移，指向下一个节点
    temp_circlelist->slider = temp_circlelistconnected_node->next;
    //返回当初得到的节点
    ret = (ListNode*)temp_circlelistconnected_node;
    return ret;

}


/***********************以下为测试代码************************/

/*
typedef struct _tag_Teacher
{

    CircleLinkListConnectedNode node;
    int age ;
    char name[];
}Teacher;

void main()
{
    List* list = NULL;
    Teacher t1,t2,t3,t4,t5;
    int kk = 0;
    Teacher* teacher = NULL;
    t1.age = 21;t2.age = 22;t3.age = 23;t4.age = 24;t5.age = 25;
    list = CircleLinkList_Create();
    if (list == NULL)
    {
        printf("创建list失败");
    }
    //尾插法
    CircleLinkList_InsertOneNode(list,(ListNode*)&t1,CircleLinkList_GetLength(list));
    CircleLinkList_InsertOneNode(list,(ListNode*)&t2,CircleLinkList_GetLength(list));
    CircleLinkList_InsertOneNode(list,(ListNode*)&t3,CircleLinkList_GetLength(list));
    CircleLinkList_InsertOneNode(list,(ListNode*)&t4,CircleLinkList_GetLength(list));
    CircleLinkList_InsertOneNode(list,(ListNode*)&t5,CircleLinkList_GetLength(list));

    //打印2边，能输出2遍，没有越界，证明是循环链表
    for (kk = 0; kk < 2*CircleLinkList_GetLength(list); kk ++)
    {
         teacher = (Teacher* )CircleLinkList_GetOneNode(list,kk);
         printf("老师%d的年龄是%d",kk,teacher->age);
         printf("\n");
    }
    CircleLinkList_DeleteOneNodeByNodePointer(list,(ListNode*)&t5);

    printf("链表长度%d \n",CircleLinkList_GetLength(list));
    for (kk = 0; kk < 2*CircleLinkList_GetLength(list); kk ++)
    {
        teacher = (Teacher* )CircleLinkList_GetOneNode(list,kk);
        printf("老师%d的年龄是%d",kk,teacher->age);
        printf("\n");
    }
    printf("链表长度%d \n",CircleLinkList_GetLength(list));
    CircleLinkList_DeleteAllNode(list);
    printf("链表长度%d \n",CircleLinkList_GetLength(list));
    CircleLinkList_Destory(list);
    system("pause");
}
*/

可能会调用其它头文件或源文件，如果调用，请翻看我的其它博客，对其头文件或源文件的实现。
good luck !