数据结构（16）循环链表

今天记录下循环链表，其实循环链表也就是将单链表中最后一个数据元素的next指针指向第一个元素。

        这里有一个概念需要说明下：

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

        如图

 

     

        这里介绍静态链表的常用操作：

                         l 创建循环链表

                         l 销毁循环链表

                         l 清空�%@E�环链表

                         l 获取表长度

                         l 把node插入pos位置

                         l 获取pos位置的元素

                         l 删除pos位置的元素

                         l 删除表中与node相同的元素（删除第一个匹配成功的）

                         l 重置游标

                         l 返回游标所指向的结点

                         l 游标后移

             

        代码总分为三个文件：

                CircleList.h ： 放置功能函数的声明，以及表的声明，表结点的定义 

  nbsp;             CircleList.c ： 放置功能函数的定义，以及表的定义

                Main.c    ： 主函数，使用功能函数完成各种需求，不过一般用作测试

       整体结构图为：

       这里详细说下插入操作和删除操作：

 

              插入操作：

                     如图

                     

                     插入元素方法：

                            判断表和插入位置是否合法

                            由表头开始通过next域移动pos次后，当前元素的next域为要插入的位置

                            将新元素插入（和单链表插入方法相同）

                            表长度加1

                            判断是否为头插（就是头结点和首元素中间插入）

                            如果是头插的话，把尾结点的next域指向第一个元素（也就是头节点所指向的首元素）

                            如果之前表为空表，则游标指向插入的结点

  

            删除操作：

                   如图

                    

                   删除元素方法：

                          判断表和插入位置是否合法

                          由表头开始通过next域移动pos次后，当前元素的next指向的元素为要删除的元素

                          删除元素�%@C�和单链表删除元素相同）

                          表长度减1

                          判断是否删除的为首元素

                          如果删除的是首元素的话，把表尾结点的next域指向首元素

                          如果删除后表为空，则重置头结点的next域和游标

                          如果删除的结点正好游标也指向它，则游标后移

   

OK! 上代码：

CircleList.h

 #ifndef _CIRCLELIST_H_
 #define _CIRCLELIST_H_

 typedef void CircleList;
 typedef struct _tag_CircleListNode CircleListNode;

 struct _tag_CircleListNode
 {
     CircleListNode* next;
 };

 CircleList* CircleList_Create();

 void CircleList_Destroy(CircleList* list);

 void CircleList_Clear(CircleList* list);

 int CircleList_Length(CircleList* list);

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

 CircleListNode*&lbsp;CircleList_Get(CircleList* list, int pos);

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

 CircleListNode* CircleList_DeleteNode(CircleLiqt* list, CircleListNode* node);

 CircleListNode* CircleList_Reset(CircleList* list);

 CircleListNode* CircleList_Current(CircleList* list);

 CircleListNode* CircleList_Next(CircleList* list);

#endif

CircleList.c

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

 typedef struct _tag_CircleList
 {
     CircleListNode header;
     CircleListNode* slider;
     int length;
 }TCircleList;

 CircleList* CircleList_Create()
 {
     TCircleList* sList = (TCircleList*)malloc(sizeof(TCircleList));

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

     return sList;
 }

 void CircleList_Destroy(CircleList* list)
 {
     free(list);
 }

 void CircleList_Clear(CircleList* list)
 {
     TCircleList* sList = (TCircleList*)list;

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

 int CircleList_Length(CircleList* list)
 {
     TCircleList* sList = (TCircleList*)list;

     int ret = -1;

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

     return ret;
 }

 int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
 {
     TCircleList* sList = (TCircleList*)list;

     int ret = (NULL!=sList)&&(NULL!=node)&&(0<=pos);

     int i = 0;

     if(ret)
     {
         CircleListNode* current = (CircleListNode*)sList;

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

         node->next = current->next;
         current->next = node;

         if(0 == sList->length)
         {
             sList->slider = node;
         }

         sList->length++;

         if(current == (CircleListNode*)sList)
         {
             CircleListNode* last = CircleList_Get(sList, sList->length-1);

             last->next = current->next;
         }
     }

     return ret;
 }

 CircleListNode* CircleList_Get(CircleList* list, int pos)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

     int i = 0;

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

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

         ret = current->next;
     }

     return ret;
 }

 CircleListNode* CircleList_Delete(CircleList* list, int pos)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

     int i = 0;

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

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

         ret = current->next;
         current->next = ret->next;

         sList->length--;

         if(current == (CircleListNode*)sList)
         {
             last = (CircleListNode*)CircleList_Get(sList, sList->length-1);
         }

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

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

         if(0 == sList->length)
         {
             sList->slider = NULL;
             sList->header.next = NULL;
         }
     }

     return ret;
 }

 CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

     int i = 0;

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

         for(i=0; i<sList->length; i++)
         {
             if(node == current->next)
             {
                 ret = current->next;
                 break;
             }

             current = current->next;
         }

         if(NULL != ret)
         {
             CircleList_Delete(sList, i);
         }
     }

     return ret;
 }

 CircleListNode* CircleList_Reset(CircleList* list)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

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

     return ret;
 }

 CircleListNode* CircleList_Current(CircleList* list)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

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

     return ret;
 }

 CircleListNode* CircleList_Next(CircleList* list)
 {
     TCircleList* sList = (TCircleList*)list;

     CircleListNode* ret = NULL;

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

     return ret;
 }

Main.c

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

 typedef struct _tag_Value
 {
     CircleListNode header;
     int v;
 }Value;

 int main(void)
 {
     int i = 0;

     CircleList* list = CircleList_Create();

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

     v1.v=1, v2.v=2, v3.v=3, v4.v=4;
     v5.v=5, v6.v=6, v7.v=7, v8.v=8;

     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, 5);

     CircleList_Delete(list, 0);

     for(i=0; i<2*CircleList_Length(list); i++)
     {
         Value* p = (Value*)CircleList_Get(list, i);

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

     while(CircleList_Length(list) > 0)
     {
         Value* p = (Value*)CircleList_Delete(list, 0);

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

     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=0; i<CircleList_Length(list); i++)
     {
         Value* p = (Value*)CircleList_Next(list);

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

     CircleList_Reset(list);

     while(CircleList_Length(list) > 0)
     {
         Value* pV = NULL;

         for(i=1; i<3; i++)
         {
             CircleList_Next(list);
         }

         pV = (Value*)CircleList_Current(list);
         printf("%d\n", pV->v);

         CircleList_DeleteNode(list, (CircleListNode*)pV);
     }

     CircleList_Destroy(list);

     return 0;
 }