数据结构之循环双链表（c语言附完整代码）

已于 2022-11-11 16:12:04 修改
阅读量875 收藏 17
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表 c++ 算法
于 2022-11-10 18:54:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62795460/article/details/127730407
版权

文章目录

定义

将双链表的尾结点next指针域由原来的为空改为指向头结点，将它的头结点prior指针域改为指向尾结点，整个双链表构成两个环，便构成了循环双链表。

示意图：
在这里插入图片描述
声明循环双链表：

typedef struct DNode		//定义双链表结点类型
{
	ElemType data;
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DLinkNode;

此处循环双链表声明与双链表一致。

注意：本文章讨论的循环双链表是带头结点的循环双链表。
增加头结点的优点如下：
1.循环双链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。
2.无论循环双链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。

基本运算

头插法建立循环双链表：

void CreateListF(DLinkNode *&L,ElemType a[],int n)
//头插法建立循环双链表
{
	DLinkNode *s;int i;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->next=NULL;
	for (i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL) L->next->prior=s;
		L->next=s;s->prior=L;
	}
	s=L->next;	
	while (s->next!=NULL)			//查找尾结点,由s指向它
		s=s->next;
	s->next=L;						//尾结点next域指向头结点
	L->prior=s;						//头结点的prior域指向尾结点

}

尾插法建立循环双链表：

void CreateListR(DLinkNode *&L,ElemType a[],int n)
//尾插法建立循环双链表
{
	DLinkNode *s,*r;int i;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  //创建头结点
	L->next=NULL;
	r=L;					//r始终指向尾结点,开始时指向头结点
	for (i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=L;				//尾结点next域指向头结点
	L->prior=r;				//头结点的prior域指向尾结点
}

初始化链表：

void InitList(DLinkNode *&L)
{
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=L;
}

销毁链表：

void DestroyList(DLinkNode *&L)
{
	DLinkNode *p=L,*q=p->next;
	while (q!=L)
	{
		free(p);
		p=q;
		q=p->next;
	}
	free(p);
}

判断链表是否为空表;

bool ListEmpty(DLinkNode *L)
{
	return(L->next==L);
}

求链表长度：

int ListLength(DLinkNode *L)
{
	DLinkNode *p=L;
	int i=0;
	while (p->next!=L)
	{
		i++;
		p=p->next;
	}
	return(i);
}

输出链表：

void DispList(DLinkNode *L)
{
	DLinkNode *p=L->next;
	while (p!=L)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

求链表某个位置数据元素的值：

bool GetElem(DLinkNode *L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p;
	if (L->next!=L)		//双链表不为空表时
	{
		if (i==1)
		{
			e=L->next->data;
			return true;
		}
		else			//i不为1时
		{
			p=L->next;
			while (j<i-1 && p!=L)
			{
				j++;
				p=p->next;
			}
			if (p==L)
				return false;
			else
			{
				e=p->data;
				return true;
			}
		}
	}
	else				//双链表为空表时
		return 0;
}

按值查找：

int LocateElem(DLinkNode *L,ElemType e)
{
	int n=1;
	DLinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		n++;
		p=p->next;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}

插入数据元素：

bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (p->next==L)					//原双链表为空表时
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		p->next=s;s->next=p;
		p->prior=s;s->prior=p;
		return true;
	}
	else if (i==1)					//原双链表不为空表但i=1时
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		s->next=p->next;p->next=s;	//将结点s插入到结点p之后
		s->next->prior=s;s->prior=p;
		return true;
	}
	else
	{	
		p=L->next;
		while (j<i-2 && p!=L)
		{	j++;
			p=p->next;
		}
		if (p==L)				//未找到第i-1个结点
			return false;
		else					//找到第i-1个结点*p
		{
			s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
			s->data=e;	
			s->next=p->next;	//将结点s插入到结点p之后
			if (p->next!=NULL) p->next->prior=s;
			s->prior=p;
			p->next=s;
			return true;
		}
	}
}

删除数据元素：

bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (p->next==L)					//原双链表为空表时
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		p->next=s;s->next=p;
		p->prior=s;s->prior=p;
		return true;
	}
	else if (i==1)					//原双链表不为空表但i=1时
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		s->next=p->next;p->next=s;	//将结点s插入到结点p之后
		s->next->prior=s;s->prior=p;
		return true;
	}
	else
	{	
		p=L->next;
		while (j<i-2 && p!=L)
		{	j++;
			p=p->next;
		}
		if (p==L)				//未找到第i-1个结点
			return false;
		else					//找到第i-1个结点*p
		{
			s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
			s->data=e;	
			s->next=p->next;	//将结点s插入到结点p之后
			if (p->next!=NULL) p->next->prior=s;
			s->prior=p;
			p->next=s;
			return true;
		}
	}
}

完整代码

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct DNode		//定义双链表结点类型
{
	ElemType data;
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DLinkNode;
void CreateListF(DLinkNode *&L,ElemType a[],int n)
//头插法建立循环双链表
{
	DLinkNode *s;int i;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->next=NULL;
	for (i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL) L->next->prior=s;
		L->next=s;s->prior=L;
	}
	s=L->next;	
	while (s->next!=NULL)			//查找尾结点,由s指向它
		s=s->next;
	s->next=L;						//尾结点next域指向头结点
	L->prior=s;						//头结点的prior域指向尾结点

}
void CreateListR(DLinkNode *&L,ElemType a[],int n)
//尾插法建立循环双链表
{
	DLinkNode *s,*r;int i;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  //创建头结点
	L->next=NULL;
	r=L;					//r始终指向尾结点,开始时指向头结点
	for (i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=L;				//尾结点next域指向头结点
	L->prior=r;				//头结点的prior域指向尾结点
}
void InitList(DLinkNode *&L)
{
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=L;
}
void DestroyList(DLinkNode *&L)
{
	DLinkNode *p=L,*q=p->next;
	while (q!=L)
	{
		free(p);
		p=q;
		q=p->next;
	}
	free(p);
}
bool ListEmpty(DLinkNode *L)
{
	return(L->next==L);
}
int ListLength(DLinkNode *L)
{
	DLinkNode *p=L;
	int i=0;
	while (p->next!=L)
	{
		i++;
		p=p->next;
	}
	return(i);
}
void DispList(DLinkNode *L)
{
	DLinkNode *p=L->next;
	while (p!=L)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
bool GetElem(DLinkNode *L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p;
	if (L->next!=L)		//双链表不为空表时
	{
		if (i==1)
		{
			e=L->next->data;
			return true;
		}
		else			//i不为1时
		{
			p=L->next;
			while (j<i-1 && p!=L)
			{
				j++;
				p=p->next;
			}
			if (p==L)
				return false;
			else
			{
				e=p->data;
				return true;
			}
		}
	}
	else				//双链表为空表时
		return 0;
}
int LocateElem(DLinkNode *L,ElemType e)
{
	int n=1;
	DLinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		n++;
		p=p->next;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (p->next==L)					//原双链表为空表时
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		p->next=s;s->next=p;
		p->prior=s;s->prior=p;
		return true;
	}
	else if (i==1)					//原双链表不为空表但i=1时
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;
		s->next=p->next;p->next=s;	//将结点s插入到结点p之后
		s->next->prior=s;s->prior=p;
		return true;
	}
	else
	{	
		p=L->next;
		while (j<i-2 && p!=L)
		{	j++;
			p=p->next;
		}
		if (p==L)				//未找到第i-1个结点
			return false;
		else					//找到第i-1个结点*p
		{
			s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
			s->data=e;	
			s->next=p->next;	//将结点s插入到结点p之后
			if (p->next!=NULL) p->next->prior=s;
			s->prior=p;
			p->next=s;
			return true;
		}
	}
}
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L,*q;
	if (p->next!=L)					//原双链表不为空表时
	{	
		if (i==1)					//i==1时
		{	
			q=L->next;				//删除第1个结点
			e=q->data;
			L->next=q->next;
			q->next->prior=L;
			free(q);
			return true;
		}
		else						//i不为1时
		{	
			p=L->next;
			while (j<i-2 && p!=NULL)		
			{
				j++;
				p=p->next;
			}
			if (p==NULL)				//未找到第i-1个结点
				return false;
			else						//找到第i-1个结点p
			{
				q=p->next;				//q指向要删除的结点
				if (q==NULL) return 0;	//不存在第i个结点
				e=q->data;
				p->next=q->next;		//从单链表中删除q结点
				if (p->next!=NULL) p->next->prior=p;
				free(q);				//释放q结点
				return true;
			}
		}
	}
	else return false;					//原双链表为空表时
}
int main()
{
	DLinkNode *L;
	ElemType e;
	ElemType a[]={1,2,3,4};
	CreateListF(L,a,4);        //尾插法建立链表 
	printf("尾插法所得顺序为: ");
	DispList(L);
	DestroyList(L);
	CreateListR(L,a,4);        //头插法建立链表 
	printf("头插法所得顺序为：");
	DispList(L);
	printf("链表的长度为:%d\n",ListLength(L));
	ListInsert(L,4,5);          //在链表第四个元素前插入5 
	printf("插入一个元素后链表的元素为:");
	DispList(L);
	ListDelete(L,1,e);          //删除链表中第一个元素，并将它的值赋给e 
	printf("删除的元素为:%d\n",e);
	printf("删除一个元素后链表的元素为:");
	DispList(L);
	printf("当前链表是否为空:%d\n",ListEmpty(L));
	GetElem(L,1,e);
	printf("链表第一个元素为:%d\n",e);
	printf("值为2的元素在链表中的位置为:%d\n",LocateElem(L,2));
	return 0;
}

参考资料：
李春葆《数据结构教程》（第五版）

hello_world&&
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点  （前驱指针或者左链指针） rLink->指向后继结点（后驱指针或者右链指针） 2.双链表常采用带附加头结点的循环链表方式： first：头指针，不存放数据，或者存放特殊要求的数据。它的lLink指向双链表的尾结点（最后一个结点）， 它的rLink指向双链表的首结点（第一个有效结点）。链表的首结点的左链指针lLink和尾结点的右链指针 rLink都指向附加头结点。 二、实现程序 1.DblList.h #ifndef DblL
第四周 项目4—建设双链表算法库
fj的博客
10-05 332
1.头文件：cdlinklist.h，包含定义双链表数据结构的代码、宏定义、要实现算法的函数的声明； //循环双链表基本运算函数 typedef int ElemType; typedef struct DNode //定义双链表结点类型 { ElemType data; struct DNode *prior; //指向前驱结点 stru
数据结构_循环双链表
FRANK48691的博客
06-13 86
循环双链表基本操作的代码实现
数据结构-循环双链表
TSZ0000的博客
09-13 269
说明      与循环单链表一样，只是末尾除的指针指向头结点，形成一个环。 代码 /* ** cdlink create by yubo.wang 2018.9.12 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef char ElemType; typedef struct node { ElemType d...
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
循环双链表的约瑟夫问题-完整代码
10-04
试用双循环链表为存储结构， 写一个约瑟夫(Josephu) 问题的算法。约瑟夫问题是：有N个人围成一圈，由第i个人开始从1报数，数到m时，此人就出列。下一个人重新从1开始报数，再数到m时，又一个人出列，直到所有的人...
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
C语言中双向链表和双向循环链表详解
12-26
而对于双循环链表，只需要最后一个元素的next指向head->next，head->next的prior指向最后一个节点即可。 插入操作 新节点s插入链表，s->next给p结点，s->prior给p->prior，然后，p->prior->next指向s，p->prior再...
数据结构链表之循环双链表
u010814426的专栏
07-27 389
对于有头结点的双链表L，当L为空时，L->pre == L && L->next == L; 对循环双链表的插入操作，需要考虑到链表为空的特殊情况； 对循环上链表的删除操作，需要考虑到被删除元素为链表中最后一个元素的特殊情况。 具体代码如下： #include #include struct List{ int val; List* pre; List* next; }; Lis
数据结构之双向循环链表
未思
02-06 901
算法与数据结构之双向循环链表
数据结构之循环双链表的结构和实现
Fenice
02-26 766
1、双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针和一个数据域（存放的是元素的值），分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。当为空表时，循环双链表只有一个头指针，并且它的前后两个指针都指向这个头指针。 #include "stdafx.h" #include using n
数据结构实现循环双链表
cf527085608的专栏
12-05 719
头文件“2_3_3.h”# include# include# includetypedef struct DuLNode{ int data; struct DuLNode *prior; struct DuLNode *next;}*DuLinkList;void CreateList(DuLinkList &L,int n){ //操作一 /
数据结构 双向循环链表
初学者的博客
07-05 366
双向循环链表
数据结构-双向循环链表
abcnull 的博客
02-15 617
文章目录简介Java 实现 简介 单链表对应着单向循环链表，即原来单链表最后一个结点指向本来为空，现在指向头结点；双向链表对应着双向循环链表，即原来双向链表最后一个结点的后驱结点为空，现在指向头结点，原来双向链表的头结点是没有前驱结点的，现在双向循环链表的头结点的前驱结点指向双向循环链表的尾结点 Java 实现 逻辑思路 逻辑上双向循环链表只不过是在双向链表上多加了循环这个条件，我们在初始化时候使...
数据结构--双向循环链表
RookiChen的博客
05-20 500
上个文章写了循环链表是如何实现的，本文的双向循环链表和循环链表类似，只不过是讲每个节点的prior指向上一个节点，再讲尾结点指向头结点，形成了一个环，双向循环链表的优点就是在查找数据时可以进行双向查找，效率比普通链表要高。 双向循环链表中每个节点定义了两个指针，next（指向下一个）和prior（指向上一个）。 增加：在增加结束前的操作和单链表相同，只是在结尾处要讲头节点的prior指向尾节点，尾节点的next指向头节点。详细代码请看下面的Add函数。 删除：删除时要进行判断删除的节点是否是头结点，详情请.
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
热门推荐
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
C语言数据结构双向循环链表
最新发布
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hello_world&&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值