文章目录
前言
单链表是一种很强大的线性表，但它不是完美无瑕的。在生活中，不是所有的事物和关系都能用单链表来表示，例如一年有12个月，并且这12个月都是循环排列的，再有就是十二生肖，都是从子鼠开始，到亥猪为一个周期，然后周而复始地循环。
单链表可以用于表示任意的线性关系，但是有些线性关系是循环的，即没有队尾元素，为此我们使用循环链表来描述这一类型的线性关系。
1.循环链表的定义
循环链表是另一种形式的链式存储结构，它的特点是将单链表中最后一个数据元素的next指针指向第一个元素，其示意图如下：
2.循环链表的操作
循环链表拥有单链表的所有操作，但是循环链表也有其独特的操作，在单链表的操作基础上还有
(1)获取当前游标指向的数据元素；
(2)将游标重置指向链表中的第一个数据元素；
(3)将游标移动指向到链表中的下一个数据元素；
(4)直接指定删除链表中的某个数据元素。
这些操作提到的游标在循环链表中可以定义为一个“当前”指针，可以通过这个游标来遍历链表中的所有元素，如下图所示：
在进行操作之前，我们要进行数据封装，结点指针域结构体定义，链表头结点结构体定义。
typedef void CircleList;
//结点指针域定义，这里相当于一条地址链，一个地址里存着下一个地址，下一个地址存着下下个地址，以此类推。
typedef struct _tag_CircleListNode CircleListNode;
struct _tag_CircleListNode
{
CircleListNode* next;
};
typedef struct _tag_CircleList //循环链表的头结点
{
CircleListNode header; //指向下一元素的指针
CircleListNode* slider; //游标（当前指针）
int length; //该循环链表的长度
} TCircleList;
2.1创建
创建循环链表时，我们先动态地申请表头结点，令链表的长度为0，表头结点的指针域为空，游标指向空。
CircleList* CircleList_Create() //O(1)
{
TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList)); //动态地申请表头节点
if (ret != NULL)
{
ret -> length = 0;
ret -> header.next = NULL;
ret -> slider = NULL;
}
return ret;
}
2.2销毁
直接free掉就行。
void CircleList_Destroy(CircleList* list) //O(1)
{
free(list);
}
2.3清空
清空循环链表就只需让它回到初始状态即可，也就是长度为0，表头结点的指针域为空，游标指向空。
void CircleList_Clear(CircleList* list) //O(1)
{
TCircleList* sList = (TCircleList*)list;
if (sList != NULL) //对循环链表的合法性检测
{
sList -> length = 0;
sList -> header.next = NULL;
sList -> slider = NULL;
}
}
2.4获取长度
获取循环链表的长度时，首先对其合法性进行检测，接着返回长度即可。
int CircleList_Length(CircleList* list) //O(1)
{
TCircleList* sList = (TCircleList*)list;
int ret = -1;
if (sList != NULL) //对循环链表的合法性检测
{
ret = sList -> length;
}
return ret;
}
2.5插入元素
插入元素的操作的步骤大部分和单链表的操作步骤一样，但也有不同之处，如果在插入操作中，我们插入的是第一个元素，我们要让第一个元素的next指针指向自己。
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) //最好O(1)，最坏O(n)
{
TCircleList* sList = (TCircleList*)list;
int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
int i = 0;
if (ret)
{
CircleListNode* current = (CircleListNode*)sList; //让current指针指向表头
for (i = 0; (i < pos) && (current -> next != NULL); i++)
{
current = current -> next;
}
node -> next = current -> next;
current -> next = node;
if (sList -> length == 0) //若插入的是第一个元素
{
sList -> slider = node; //将游标指向刚刚插入的第一个结点
}
sList -> length++;
if (current == (CircleListNode*)sList) //若插入的位置是第0个位置
{
CircleListNode* last = CircleList_Get(sList, sList -> length - 1); //获取最后一个元素
last -> next = current -> next;
}
}
return ret;
}
2.6获取元素
获取元素的操作和单链表的操作几乎没什么区别，唯一的区别就是在进行合法性判断时，获取元素的位置只需要大于等于0即可，因为循环链表是有周期的。
CircleListNode* CircleList_Get(CircleList* list, int pos) //最好O(1)，最坏O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;
if ((sList != NULL) && (pos >= 0))
{
CircleListNode* current = (CircleListNode*)sList; //让current指针指向表头
for (i = 0; i < pos; i++)
{
current = current -> next;
}
ret = current -> next; //返回指向元素的指针
}
return ret;
}
2.7删除元素
在删除一个元素时，我们要考虑到删除前的情况，删除以后链表是否为空，删除的元素是否为第一个元素，删除的元素是否为游标所指向的元素。
若删除元素后链表为空，则我们应该让链表回到初始状态，也就是和清空的状态一样。
若删除的元素为第一个元素，那么头结点指针和最后一个元素的指针应该第一个元素的next域。
若删除的元素为游标所指向的元素，则游标应该指向删除元素后面一个元素。
CircleListNode* CircleList_Delete(CircleList* list, int pos) //最好O(1)，最坏O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;
if ((sList != NULL) && (pos >= 0) && (sList -> length > 0))
{
CircleListNode* current = (CircleListNode*)sList; //让current指针指向表头
CircleListNode* first = (CircleListNode*)sList -> header.next; //链表中的第一个元素
CircleListNode* last = NULL; //链表中的最后一个元素
for (i = 0; i < pos; i++)
{
current = current -> next;
}
if (current == (CircleListNode*)sList) //若当前指向表头
{
last = (CircleListNode*)CircleList_Get(sList, sList -> length - 1);
}
ret = current -> next; //指向元素的指针
current -> next = ret -> next;
sList -> length--;
if (last != NULL) //如果被删除的元素是第一个元素
{
sList -> header.next = ret -> next; //头结点指向第一个元素的next域
last -> next = ret -> next; //最后一个元素指向第一个元素的next域
}
if (ret == sList -> slider) //如果被删除的元素正好是游标所指的元素
{
sList -> slider = ret -> next;
}
if (sList -> length == 0) //若链表被删后为空
{
sList -> header.next = NULL; //链表回到初始状态
sList -> slider = NULL;
}
}
return ret;
}
2.8删除指定元素
删除指定元素，我们首先对链表进行合法性检测，然后找到指定元素的逻辑位置，找到以后将其删除。
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)//O(n)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
int i;
if (sList != NULL)
{
CircleListNode* current = (CircleListNode*)sList; //current指针指向表头
for (i = 0; i < sList -> length; i++)
{
if (current -> next == node) //若找到元素的逻辑位置
{
ret = current -> next; //指向指定元素的指针
break;
}
current = current -> next;
}
if (ret != NULL)
{
CircleList_Delete(sList, i);
}
}
return ret;
}
2.9重置游标
游标重置指向链表中的第一个元素。
CircleListNode* CircleList_Reset(CircleList* list) //O(1)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
if (sList != NULL)
{
sList -> slider = sList -> header.next;
ret = sList -> slider;
}
return ret;
}
2.10获取当前游标指向的数据元素
CircleListNode* CircleList_Current(CircleList* list) //O(1)
{
TCircleList* sList = (TCircleList*)list;
CircleListNode* ret = NULL;
if (sList != NULL)
{
ret = sList -> slider;
}
return ret;
}
2.11移动游标指向下一个元素
将游标移动指向到链表中的下一个数据元素。
CircleListNode* CircleList_Next(CircleList* 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;
}
3.测试
3.1常规测试
对循环链表进行常规测试，重要就是测试其一般操作。
#include <stdio.h>
#include <stdlib.h>
#include "CircleList.h"
typedef struct Value
{
CircleListNode header;
int v;
} Val;
int main(int argc, char *argv[])
{
int i = 0;
Val v1, v2, v3, v4, v5, v6, v7, v8;
Val* p;
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* list = CircleList_Create();
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));
for (i = 0; i < CircleList_Length(list); i++)
{
p = (Val*)CircleList_Get(list, i);
printf("%d\n", p -> v);
}
printf("\n");
while(CircleList_Length(list) > 0)
{
p = (Val*)CircleList_Delete(list, 0);
printf("%d\n", p -> v);
}
CircleList_Destroy(list);
return 0;
}
得到的结果为：
3.2循环链表测试
循环链表的测试就是主要查看链表以一个周期来进行循环，因此我们只需在一个大于周期的位置插入元素测试。
#include <stdio.h>
#include <stdlib.h>
#include "CircleList.h"
typedef struct Value
{
CircleListNode header;
int v;
} Val;
int main(int argc, char *argv[])
{
int i = 0;
Val v1, v2, v3, v4, v5, v6, v7, v8;
Val* p;
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* list = CircleList_Create();
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);
for (i = 0; i < CircleList_Length(list); i++)
{
p = (Val*)CircleList_Get(list, i);
printf("%d\n", p -> v);
}
printf("\n");
while(CircleList_Length(list) > 0)
{
p = (Val*)CircleList_Delete(list, 0);
printf("%d\n", p -> v);
}
CircleList_Destroy(list);
return 0;
}
得到的结果为：
当我们在第5个位置插入元素时，相当于在第2个位置插入。
3.3约瑟夫问题
n个人围成一个圆圈，首先从第1个人开始一个人一个人顺时针报数，报到第m个人，令其出列，然后再从下一个人开始从1顺时针报数，报到第m个人，再令其出列，……，如此下去，求出列顺序。其示意图如下：
图中，8个人围成一圈，从第一个人开始，每个人顺时针报数，报到3的人出列。
#include <stdio.h>
#include <stdlib.h>
#include "CircleList.h"
typedef struct Value
{
CircleListNode header;
int v;
} Val;
int main(int argc, char *argv[])
{
int i = 0;
Val v1, v2, v3, v4, v5, v6, v7, v8;
Val* p;
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* list = CircleList_Create();
/*约瑟夫问题*/
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++)
{
p = (Val*)CircleList_Next(list);
printf("%d\n", p -> v);
}
printf("\n");
CircleList_Reset(list); //重置游标
while(CircleList_Length(list) > 0)
{
p = NULL;
for (i = 1; i < 3; i++)
{
CircleList_Next(list);
}
p = (Val*)CircleList_Current(list);
printf("%d\n", p -> v);
CircleList_DeleteNode(list, (CircleListNode*)p);
}
CircleList_Destroy(list);
return 0;
}
首先我们创建了8个元素构成的环，接着重置了游标，利用了循环链表的独特操作来求解约瑟夫问题，结果为：
4.总结
1.循环链表只是在单链表的基础上做了一个加强；
2.循环链表可以完全取代单链表的应用；
3.循环链表的Next和Current操作可以高效地遍历链表中的所有元素。
扫一扫
1034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
