数据结构（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

[cpp] view
plaincopy

#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

[cpp] view
plaincopy

#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

[cpp] view
plaincopy

#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;

}