文章目录
前言
本文主要讲述循环链表的基本定义特点以及一些常见操作并使用C语言代码对其进行实现。
一、循环链表基本概念
循环链表（Circular Linked List）是一种链表的变体，它与单向链表相似，但是最后一个节点的指针指向第一个节点，形成了一个环状结构。循环链表可以被看作是一个循环数组的链式表示形式。
在循环链表中，每个节点包含数据域和指针域。指针域中存储的是下一个节点的地址或位置。最后一个节点的指针指向第一个节点，形成一个闭环。在循环链表中，我们可以通过任意一个节点来遍历整个链表。
循环链表可以用来实现循环缓冲区等数据结构。例如，在操作系统中，我们可以用循环链表来实现一个环形缓冲区，用于存储进程的PCB（Process Control Block）信息。当缓冲区满时，新的进程可以覆盖旧的进程的信息，从而实现缓冲区的循环使用。
实现循环链表需要处理一些特殊情况，例如在插入和删除节点时需要更新相应的指针。在遍历循环链表时，我们需要特别注意不要陷入无限循环。
二、循环链表特点
- 循环链表中的最后一个结点的指针域指向头结点，整个链表形成一个环。
- 从循环链表中任一结点出发，都能访问到表中其他结点。
- 循环链表是将表中最后一个结点的指针域指向头结点，并不增加额外存储花销。
- 循环链表是单向链表的扩展，它保持了单向链表的所有特性。
- 循环链表首尾相接，从任何一个节点出发都能访问到表中其他所有节点。
- 循环链表可以用来实现循环缓冲区等数据结构。
三、循环链表运算
1、创建循环链表
创建一个循环链表需要先定义一个节点结构体，包含数据域和指向下一个节点的指针。然后定义一个头节点，其指向下一个节点的指针指向自身，形成一个环。
代码实现：
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误， 初始化失败！[100001]\n");
return 100001;
}
(*Head)->next = *Head;
return 0;
}
else
{
printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
return 100002;
}
}2、插入头节点
- 创建一个新的节点，将要插入的数据存储在该节点中。
- 如果链表为空，则将新节点设置为头节点。
- 如果链表不为空，则将新节点的next指向原来的头节点。
- 将头节点更新为新节点。
代码实现：
int insert_head(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
// 改变 newHead.next
newNode->next = (*Head)->next;
(*Head)->next = newNode;
return 0;
}3、插入尾节点
- 创建一个新的节点，将要插入的数据存储在该节点中。
- 如果链表为空，则将新节点设置为头节点，并将头节点的next指向新节点。
- 如果链表不为空，则将新节点的next指向当前最后一个节点（即头节点），并将最后一个节点的next指向新节点。
- 将头节点更新为新节点。
代码实现：
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = *Head;
p = (*Head);
while(p->next != (*Head))
{
p = p->next;
}
p->next = newNode;
return 0;
}5、在指定位置插入元素
- 创建新节点：首先，创建一个新的节点，并将要插入的数据存储在该节点中。
- 找到插入位置：根据要插入的位置，找到循环链表中对应的前一个节点。如果插入位置为链表的头部，则直接找到头节点即可。如果插入位置为链表的尾部，则需要遍历整个链表直到找到最后一个节点。
- 插入新节点：将新节点的next指向当前位置的下一个节点。然后将前一个节点的next指向新节点。这样，新节点就被插入到了指定位置。
代码实现：
int insert(SingleLinkList **Head, int i, DataType x)
{
int j;
SingleLinkNode *p;
SingleLinkNode *newNode;
if(i<1 || i>length(*Head)+1)
{
printf("位置i不是链表有效位置！[100005]\n");
return 100005;
}
p = (*Head);
j = 1;
while(j<i)
{
j++;
p = p->next;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
newNode->data = x;
newNode->next = p->next;
p->next = newNode;
return 0;
}6、删除元素
- 找到要删除的节点的前一个节点。如果要删除的是头节点，则直接找到头节点即可。如果要删除的是尾节点，则需要遍历整个链表找到倒数第二个节点。
- 将要删除的节点的next指向下一个节点的next。如果要删除的是头节点，则直接将头节点的next指向第二个节点。
- 释放要删除的节点的内存。
代码实现：
/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
int i;
int j;
SingleLinkNode *p;
SingleLinkNode *q; /*要删除的元素x*/
i = find(*Head,x);
if(!i)
{
printf("元素x【%d】不存在！100006\n", x);
return 100006;
}
p = (*Head);
j=1;
while(j<i)
{
j++;
p = p->next;
}
q = p->next;
p->next = q->next;
free(q); /*释放内存*/
return 0;
}
7、输出链表长度
要输出循环链表的长度，需要遍历循环链表并计算链表中的节点数。以下是使用C语言输出循环链表长度的示例代码
代码实现：
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p!=Head)
{
len++;
p = p->next;
}
return len;
}8、输出循环链表
代码实现：
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(p==Head)
{
printf("链表为空！\n");
return;
}
while(p!=Head)
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}四、循环链表的优缺点
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成了一个循环。以下是循环链表的一些优缺点。
1、优点
- 动态数据结构：循环链表是一种动态排列，可以通过分配和刷新内存在运行时增长和收缩。
- 内存利用率：循环链表可以有效地使用内存，因为链表的大小动态增加或减少，不会浪费内存。
- 易于数据操作：可以有效地处理循环链表的插入和删除，无需移动元素，只需更新下一个指针中存在的地址。
2、缺点
- 不支持随机访问，缓存命中率相对低。
- 设计数据结构时较为麻烦。
- 占用更多的内存空间：空间换时间。
- 数据结构复杂
总之，循环链表具有一定的优点和缺点，需要根据具体的应用场景和使用需求来选择是否使用循环链表。
五、完整代码
1、代码实现
SingleLinkList.c
/*
SingleLinkList.c
*/
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>
/*1. 初始化*/
int init(SingleLinkList **Head)
{
if(1)
{
/*申请内存*/
(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
/*判断内存申请是否成功*/
if(*Head == NULL)
{
printf("申请内存错误， 初始化失败！[100001]\n");
return 100001;
}
(*Head)->next = *Head;
return 0;
}
else
{
printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
return 100002;
}
}
/*2. 插入元素,头插法 */
int insert_head(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
// 改变 newHead.next
newNode->next = (*Head)->next;
(*Head)->next = newNode;
return 0;
}
/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
SingleLinkNode *newNode;
SingleLinkNode *p;
if(0)
{
printf("链表未初始化！[100003]\n");
return 100003;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
if(!newNode)
{
printf("申请节点内存空间失败！[100004]\n");
return 100004;
}
newNode->data = x;
newNode->next = *Head;
p = (*Head);
while(p->next != (*Head))
{
p = p->next;
}
p->next = newNode;
return 0;
}
/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
int j;
SingleLinkNode *p;
SingleLinkNode *newNode;
if(i<1 || i>length(*Head)+1)
{
printf("位置i不是链表有效位置！[100005]\n");
return 100005;
}
p = (*Head);
j = 1;
while(j<i)
{
j++;
p = p->next;
}
newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
newNode->data = x;
newNode->next = p->next;
p->next = newNode;
return 0;
}
/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
int i;
int j;
SingleLinkNode *p;
SingleLinkNode *q; /*要删除的元素x*/
i = find(*Head,x);
if(!i)
{
printf("元素x【%d】不存在！100006\n", x);
return 100006;
}
p = (*Head);
j=1;
while(j<i)
{
j++;
p = p->next;
}
q = p->next;
p->next = q->next;
free(q); /*释放内存*/
return 0;
}
/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
int i;
SingleLinkNode *p;
i = 1;
p = Head->next;
while( p!= Head && p->data != x)
{
i++;
p = p->next;
}
if(p->next == Head)
{
return 0;
}
else
{
return i;
}
}
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
int len=0;
SingleLinkNode *p;
p = Head->next;
while(p!=Head)
{
len++;
p = p->next;
}
return len;
}
/*6.输出链表*/
void print(SingleLinkList *Head)
{
SingleLinkNode *p;
int i=0;
p = Head->next;
if(p==Head)
{
printf("链表为空！\n");
return;
}
while(p!=Head)
{
printf("Node[%d]. = %d\n", ++i, p->data);
p = p->next;
}
}main.c
#include <stdio.h>
#include <string.h>
#include "SingleLinkList.h"
#include "welcome.h"
int main(int argc, char* argv[])
{
SingleLinkList *Head;
DataType x;
int i,m,n,cmd;
for(i=0;i<strlen(welcome);i++)
{
printf("%c",welcome[i]);
for(m=0;m<1000;m++)
for(n=0;n<1000;n++)
{
;
}
}
printf("-----------简单链表演示程序----------\n");
do
{
printf("1. 初始化链表表\n");
printf("2. 插入元素（头插法）\n");
printf("3. 插入元素（尾插法）\n");
printf("4. 插入元素（在位置i插入）\n");
printf("5. 查找元素x\n");
printf("6. 求链表长度\n");
printf("7. 输出链表\n");
printf("8. 删除元素\n");
printf("10. 帮助\n");
printf("0. 退出\n");
printf("请输入您要进行的操作（1~6,0退出）：");
scanf("%d", &cmd);
switch(cmd)
{
case 1:
if(!init(&Head))
{
printf("链表已初始化！\n");
}
break;
case 2:
printf("请输入插入元素x：x=");
scanf("%d",&x);
if(!insert_head(&Head,x))
{
printf("元素（%d）已插入\n", x);
}
break;
case 3:
printf("请输入插入元素x：x=");
scanf("%d",&x);
if(!insert_tail(&Head,x))
{
printf("元素（%d）已插入\n", x);
}
break;
case 4:
printf("请输入插入元素位置i和元素x（i，x）：");
scanf("%d,%d", &i, &x);
if(!insert(&Head, i, x))
{
printf("已在位置（%d）插入元素（%d）！\n",i, x);
}
break;
case 5:
printf("请输入要查找的元素x：");
scanf("%d", &x);
if(i = find(Head,x))
{
printf("元素%d存在，在链表位置%d.\n", x, i);
}
else
{
printf("在链表中未找到元素x。\n");
}
break;
case 6:
printf("链表的长度为：%d\n", length(Head));
break;
case 7:
print(Head);
break;
case 8:
printf("请输入要删除的元素x：");
scanf("%d", &x);
if(!delete(&Head, x))
{
printf("元素x【%d】已删除!\n", x);
}
break;
case 10:
printf(" 本程序为链表的演示程序，有ZMQ设计开发，程序完成了。。。。功能！。。。\n");
break;
}
}while(cmd != 0);
return 0;
}2、运行结果
六、总结
以上就是对循环链表的基本介绍，本文仅仅简单介绍了循环链表的概念、特点、运算以及循环链表的优缺点比较。特别注意当我们在实现循环连表时， 循环单链表没有明显的结束条件，很容易陷入死循环。此时，我们可以设置一个标记点作为循环的标记，当我们知道表长，我们也可以设置一个计数器来结束循环。
1230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
