循环链表详解(C语言)

文章目录

前言

一、循环链表基本概念

二、循环链表特点

三、循环链表运算

 1、创建循环链表

 2、插入头节点

3、插入尾节点

5、在指定位置插入元素

6、删除元素

7、输出链表长度

8、输出循环链表

四、循环链表的优缺点

1、优点

2、缺点

五、完整代码

1、代码实现

2、运行结果

六、总结


前言

本文主要讲述循环链表的基本定义特点以及一些常见操作并使用C语言代码对其进行实现。


一、循环链表基本概念

循环链表(Circular Linked List)是一种链表的变体,它与单向链表相似,但是最后一个节点的指针指向第一个节点,形成了一个环状结构。循环链表可以被看作是一个循环数组的链式表示形式。

在循环链表中,每个节点包含数据域和指针域。指针域中存储的是下一个节点的地址或位置。最后一个节点的指针指向第一个节点,形成一个闭环。在循环链表中,我们可以通过任意一个节点来遍历整个链表。

循环链表可以用来实现循环缓冲区等数据结构。例如,在操作系统中,我们可以用循环链表来实现一个环形缓冲区,用于存储进程的PCB(Process Control Block)信息。当缓冲区满时,新的进程可以覆盖旧的进程的信息,从而实现缓冲区的循环使用。

实现循环链表需要处理一些特殊情况,例如在插入和删除节点时需要更新相应的指针。在遍历循环链表时,我们需要特别注意不要陷入无限循环。

二、循环链表特点

  1. 循环链表中的最后一个结点的指针域指向头结点,整个链表形成一个环。
  2. 从循环链表中任一结点出发,都能访问到表中其他结点。
  3. 循环链表是将表中最后一个结点的指针域指向头结点,并不增加额外存储花销。
  4. 循环链表是单向链表的扩展,它保持了单向链表的所有特性。
  5. 循环链表首尾相接,从任何一个节点出发都能访问到表中其他所有节点。
  6. 循环链表可以用来实现循环缓冲区等数据结构。

三、循环链表运算

 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、插入头节点
  1. 创建一个新的节点,将要插入的数据存储在该节点中。
  2. 如果链表为空,则将新节点设置为头节点。
  3. 如果链表不为空,则将新节点的next指向原来的头节点。
  4. 将头节点更新为新节点。

代码实现:

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、插入尾节点
  1. 创建一个新的节点,将要插入的数据存储在该节点中。
  2. 如果链表为空,则将新节点设置为头节点,并将头节点的next指向新节点。
  3. 如果链表不为空,则将新节点的next指向当前最后一个节点(即头节点),并将最后一个节点的next指向新节点。
  4. 将头节点更新为新节点。

代码实现:

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、在指定位置插入元素
  1. 创建新节点:首先,创建一个新的节点,并将要插入的数据存储在该节点中。
  2. 找到插入位置:根据要插入的位置,找到循环链表中对应的前一个节点。如果插入位置为链表的头部,则直接找到头节点即可。如果插入位置为链表的尾部,则需要遍历整个链表直到找到最后一个节点。
  3. 插入新节点:将新节点的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、删除元素
  1. 找到要删除的节点的前一个节点。如果要删除的是头节点,则直接找到头节点即可。如果要删除的是尾节点,则需要遍历整个链表找到倒数第二个节点。
  2. 将要删除的节点的next指向下一个节点的next。如果要删除的是头节点,则直接将头节点的next指向第二个节点。
  3. 释放要删除的节点的内存。

代码实现:

/*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、运行结果


六、总结

以上就是对循环链表的基本介绍,本文仅仅简单介绍了循环链表的概念、特点、运算以及循环链表的优缺点比较。特别注意当我们在实现循环连表时, 循环单链表没有明显的结束条件,很容易陷入死循环。此时,我们可以设置一个标记点作为循环的标记,当我们知道表长,我们也可以设置一个计数器来结束循环。

  • 3
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值