C语言数据结构之循环链表

已于 2023-11-02 23:30:43 修改
阅读量603 收藏 3
点赞数 1
文章标签： 数据结构 c语言 链表
于 2023-10-15 18:38:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58303983/article/details/133842763
版权

一 、循环链表

  1. 定义：循环链表（Circular Linked List）是一种特殊的数据结构，它与单链表相似，但是最后一个节点的指针指向第一个节点，形成一个环状结构。在循环链表中，可以通过任何一个节点来遍历整个链表。
  2. 优点：可以支持O(1)时间复杂度的情况下的前驱节点查找，双向链表在某些情况下的插入、删除等操作要比单链表简单、高效。循环链表是一种首尾相连的单链表，从当前任意一个节点起都能遍历整个链表
  3. 缺点：循环链表不支持随机访问，缓存命中率相对低。循环链表的设计和操作比单链表更加复杂。

二、 运算      

循环链表是一种链表，其中最后一个元素指向第一个元素，形成循环。循环链表的基本运算包括创建、插入、删除、遍历等。下面简要介绍这些基本运算的方法。

1.创建循环链表：
创建一个循环链表需要先定义一个节点结构体，包含数据域和指针域。指针域至少包括一个指向下一个节点的指针，一个指向前一个节点的指针（在第一个节点中为NULL），以及一个指向链表头节点的指针。根据需要，还可以添加其他指针域。

2.插入节点：
插入节点包括在链表尾部插入节点和在指定位置插入节点。

在链表尾部插入节点的步骤如下：

创建一个新节点；
将新节点的数据域赋值；
将新节点的next指针指向头节点；
将头节点的prev指针指向新节点；
将新节点的prev指针指向头节点；
将头节点的next指针指向新节点。
在指定位置插入节点的步骤如下：

找到插入位置的前一个节点；
将新节点的next指针指向前一个节点的next指针所指向的节点；
将新节点的prev指针指向前一个节点；
将前一个节点的next指针指向新节点；
将前一个节点的next指针指向新节点的next指针所指向的节点。
3.删除节点：
删除节点包括删除头节点和删除指定节点。删除头节点的步骤如下：

将头节点的prev指针的next指针指向头节点的next指针所指向的节点；

将头节点的next指针的prev指针指向头节点的prev指针所指向的节点；

释放头节点的内存空间。
删除指定节点的步骤如下：

找到要删除的节点的前一个节点；

将要删除的节点的prev指针的next指针指向要删除的节点的next指针所指向的节点；

将要删除的节点的next指针的prev指针指向要删除的节点的prev指针所指向的节点；

释放要删除的节点的内存空间。

4.遍历链表：
遍历循环链表的基本思路是从头节点开始，依次遍历每个节点，直到回到头节点。每个节点被遍历一次后，它的next指针所指向的节点将被遍历。当next指针指向头节点时，表明已经遍历到链表的尾部。

  • 简单链表的定义及初始化
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}SingleLinkList, SingleLinkNode;
int init(SingleLinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next = NULL;
		/*循环链表*/
		/*
			(*Head)->next = *Head;
		*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}
  • 插入元素,头插法 
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;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}
  •  插入元素， 尾插法
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)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}
  • 插入元素，在位置i处插入元素x
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	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是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}
  • 删除元素, 删除值为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;
}
  • 查找值为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;
	}

}
  • 链表长度
int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head) 
	{
		len++;
		p = p->next;
	}
	return len;
}
  • 输出链表 
void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(!p)
	/*if(p!=Head)*/
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

循环链表程序

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(" 本程序为链表的演示程序，有XXX设计开发，程序完成了。。。。功能！。。。\n");
			break;
			
		}
	}while(cmd != 0);

	return 0;
}

三、结果运算图

 

小结：

 感谢季老师的辛勤付出和教诲，为我们的成长和发展奠定了坚实的基础

枫林听雨°
关注
数据结构_循环链表(C语言)
小黯
07-17 848
循环链表 1.结构解析 循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 图示： 2.源代码: #include<stdio.h> #include<stdlib.h> typedef char ElemType; typedef struct CNode { ElemType data; struct CNode *next; }CNode, *CLinkList; void InitList(CLinkList
c语言 实现循环链表
jiangjun_feng的博客
05-01 616
原文地址 挺厉害的，没有错误 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Status; // Status是函数结果状态，成功返回TRUE,失败返回FALSE typedef int ElemType; /* 线性表的循环链表存储结构 */ typedef struct node { ElemType data; struct node *next; }
C语言数据结构之循环链表的简单实例
12-26
C语言数据结构之循环链表的简单实例 实例代码： # include # include typedef struct node //定义链表中结点的结构 { int code; struct node *next; }NODE,*LinkList; /*错误信息输出函数*/ void Error(char *message) { fprintf(stderr,"Error:%s/n",message); exit(1); } //创建循环链表 LinkList createList(int n) { LinkList head; //头结
详解循环链表（数据结构C语言）
m0_59068067的博客
10-15 1310
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
C语言：数据结构链表基本操作（增、删、改、查、遍历）
weixin_47829690的博客
07-15 973
链表：在物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。由一系列节点（链表中每一个元素称为节点/结点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。链表可以分为单向链表和双向链表两种形式。在单向链表中，每个节点只保存指向下一个节点的指针，而在双向链表中，每个节点同时保存指向上一个节点和下一个节点的指针。
循环链表（C语言)
weixin_54454406的博客
10-15 273
注意：我们需要首先创建一个新的节点，然后调整节点的指针以适应新的链表结构。否则，将其添加到尾节点的后面，并更新尾节点为新节点。当插入新节点时，利用头节点的指针域始终指向头节点的后继节点的特点，来对新插入的节点完成前驱后继节点的设置。1.4：删除指定节点：前一个节点的 next 指针指向当前节点的下一个节点，从而删除当前节点。1.5：查找指定值：遍历链表中的每个节点，如果节点的数据等于目标值，就返回该节点在链表中的位置。头和尾插法建立：在循环链表的尾部或指定位置插入一个新的节点，更新后继指针和头节点指针。
C语言实现循环链表
Luminescent_fish的博客
01-26 781
数据结构学习笔记|循环链表的创建、初始化、判空与表尾结点判断的代码实现
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
C语言数据结构之判断循环链表空与满
01-21
C语言数据结构之判断循环链表空与满 前言： 何时队列为空？何时为满？ 由于入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，故队空和队满时头尾指针均相等。因此，我们无法通过front=rear来判断队列“空...
【c语言】循环链表（适合初学者）
weixin_74337975的博客
04-07 2359
循环链表是一种特殊的链表数据结构，与单向链表或双向链表相比，循环链表的最后一个节点的下一个节点指向第一个节点，从而形成一个环形结构。因此，循环链表可以在最后一个节点后继续添加节点，并且可以像单向链表或双向链表一样遍历、查找和删除节点。循环链表通常有一个头指针和一个尾指针，它们指向第一个节点和最后一个节点，以便在添加或删除节点时快速定位。循环链表可以用于解决某些问题，例如模拟一个环形队列，或者用于实现循环播放的音乐列表等。
C例子：循环链表
06-13
该程序是我写的博客“一起talk C栗子吧（第十四回：C语言实例--循环列表）”的配套程序，共享给大家使用
数据结构之循环链表（C语言）
sskdspdl的博客
09-03 835
用C语言实现循环链表
【C语言数据结构】之循环链表
最新发布
weixin_61276540的博客
09-18 864
本文主要讲解数据结构的循环链表。主打一个手搓代码，能把代码写出来才是最重要的事情。
循环链表（c语言版）
瑞_板凳精神
03-13 322
#include<stdio.h> #include<malloc.h> #include<string.h> #include<stdlib.h> #include<windows.h> typedef struct Node { //定义连接链表的节点： Node* next; }node; typedef struct Common_list { //定义一个空间域 node head; int length; }common_
c语言实现循环链表
m0_51835877的博客
10-27 907
循环链表的创建其实并不复杂，只需要在创建单链表时定义一个节点（本文章中为s）参与循环找到尾节点然后让其指向头节点的下一个（因为第一个节点时没有值的），在之后的遍历中则需要使用do while循环因为跳跃了第一个节点在我们遍历时新的第一个节点是有值的，之后的插入删除查找操作，则是在原文的基础上删除了循环中超越元素值的条件，举例：现有四个元素：1 2 3 4，删除第7个元素后：1 2 4. #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #incl
循环链表-数据结构（C语言）
2301_79870182的博客
10-14 211
在将循环链表之前我们第一步要掌握的是链表，循环链表是链表的一种。循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。
C语言数据结构双向循环链表
09-27
双向循环链表是一种常用的链表结构，它与单向链表相比具有更好的灵活性和操作效率。在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; typedef struct ListNode { struct ListNode* next; struct ListNode* prev; LTDataType data; } LTNode; void InitDList(LTNode** pHead) { *pHead = (LTNode*)malloc(sizeof(LTNode)); (*pHead)->next = *pHead; (*pHead)->prev = *pHead; } ``` 在上述代码中，`InitDList`函数用于初始化一个双向循环链表，它使用一个头节点指针作为参数，通过动态内存分配来创建一个头节点，并将头节点的`next`和`prev`指针均指向自身，从而形成一个空的循环链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值