【数据结构】带头双向循环链表

已于 2023-01-09 23:35:51 修改
阅读量96 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-01-09 23:00:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52347974/article/details/128584918
版权

一、双向循环链表（带头双向循环链表）

上一篇已经介绍过链表的相关概念，并且对单链表进行了详细讲解，这一篇将继续对双链表进行详细讲解。
既然已经学习了单链表，那为什么还要学习带头双向循环链表呢？因为单链表是存在缺陷的，它是单向非循环链表，我们只能通过指针plist(单链表为非空链表时，plist指向第一个结点的位置，单链表为空链表时，plist的值为NULL)去查找它的结点。当单链表为非空链表时，我们只能通过指针plist直接找到它的第一个结点，而其它的结点都需要通过指针plist从前往后遍历查找。这将会在很大程度上限制我们的操作，非常不方便，而双向循环链表可以很好的解决这些问题。

双向链表结点结构体：
一个数据域，两个指针域，两个指针分别指向前一个结点和后一个结点。
代码"typedef int LTDataType"重命名是因为当结点所存数据类型发生改变时方便统一更换，只要在这里将int改成相应的数据类型就行（结点结构体里的变量data的数据类型就是LTDataType）

typedef int LTDataType; 
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;//指向前一个结点
	struct ListNode* next;//指向后一个结点
}LTNode;

带头双向循环链表的结构：

当它为空链表时，只有一个头结点，该头结点的两个两个指针都指向自己。
在这里插入图片描述
当它为非空链表时。
在这里插入图片描述
从带头双向循环链表的结构就可以看出来，它可以由给出的，一个结点找到其它任意的结点，而且可以由头节点直接找到尾结点，任何时候它的指针都不可能为NULL值，所以用起来特别方便。

二、函数的实现

1、动态申请一个结点


//申请一个节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL) //检查动态申请是否失败
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

2、初始化

为什么需要初始化，因为带头双向循环链表不管是不是空链表都会有一个头结点（要注意此处头节点是指哨兵位头结点，而不是第一个存数据的结点，不要搞混了），

//初始化
LTNode* LTInit()
{
	LTNode* phead=BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

3、尾插

对于带头双向循环链表可以通过phead快速找到尾结点，从而进行尾插操作，而且不管被尾插的链表是不是空链表，都不会改变phead的值。这样不需要对链表为空链表时进行特殊的考虑（这是带头结点对于尾插的优势）

在这里插入图片描述在这里插入图片描述

//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
	assert(phead); //判断指针是否为空

	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;
	
}

4、 尾删

尾删需要注意不要将头结点删掉。对于带头双向循环链表可以快速通过尾结点找到前一个结点，这样有利于尾删，而且尾删时也不会改变phead的值。

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next !=phead);//防止头节点被删除

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	phead->prev = tailPrev;
	tailPrev->next = phead;
	free(tail);//将被删的结点释放掉
}

5、头插

不管链表为不为空都可以直接进行头插，也不会改变phead的值。

//头插
void LTPushFront(LTNode* phead,LTDataType x)
{
	assert(phead);
	LTNode* newnode=BuyLTNode(x);
	newnode->next= phead->next;
	phead->next->prev = newnode;
	phead->next= newnode;
	newnode->prev=phead;
}

6、头删

头删比较简单，但要注意不要将头结点删掉。

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);//防止将头结点删掉

	LTNode* cur = phead->next;
	LTNode* next = cur->next;
	free(cur);
	phead->next = next;
	next->prev = phead;
}

7、打印

从第一个存储数据的结点开始依次往后，当前结点不是头结点时，对其进行打印操作。

//打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

8、查找

从第一个存储数据的结点开始依次往后，当前结点不是头结点时，对其进行查找操作，如果找到则返回该结点地址，如果最终没有找到则返回NULL。

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

9、在pos位置之前插入

因为“带头双向循环链表”本身已经带头结点了，所以不管pos位置是第一个结点还是其它存储数据的结点，对其进行”在pos位置之前插入“操作都不会改变phead的值。

这里解释下为什么“带头双向循环链表”只有“在pos位置之前插入”而不像单链表还有“在pos位置之后插入”，因为单链表从pos位置找后一个结点可以通过pos->next直接找到，但找前一个结点却只能从前往后遍历查找，所以单链表“在pos位置之后插入”的操作可以很便利的插入数据，但“带头双向循环链表”不需要这样，因为它是循环链表，它通过pos位置查找前一个结点和查找后一个结点是同样方便的。

//在pos之前插入
void LTInsert(LTNode* pos,LTDataType x)
{
	assert(pos);//判断指针不为空
	
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

10、删除pos位置

因为“带头双向循环链表”本身已经带头结点了，所以不管pos位置是第一个结点还是其它存储数据的结点，对其进行“删除pos位置”操作都不会改变phead的值。

//删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);//判断指针不为空

	LTNode* first = pos->prev;
	LTNode* second= pos->next;

	free(pos);
	first->next = second;
	second->prev = first;
}

11、判空

如果phead->next == phead，则该链表为空。

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

12、求链表长度

//求链表长度
size_t LTSize(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	size_t size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

13、销毁

先将存储数据的第一个结点到最后一个结点释放掉，再将头结点释放掉。

这里还要注意，在调用完该函数之后，要将该链表的头指针置为空，因为该函数该从实参到形参是传值（头指针变量的值），而不是传址（头指针变量的地址），无法通过将形参phead置为NULL从而达到将实参也变为NULL的效果。

//销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);

}

三、 源代码

List.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;


LTNode* BuyLTNode(LTDataType x);

//初始化
LTNode* LTInit();

//尾插
void LTPushBack(LTNode* phead, LTDataType x);

//尾删
void LTPopBack(LTNode* phead);

//头插
void LTPushFront(LTNode* phead, LTDataType x);

//头删
void LTPopFront(LTNode* phead);

//打印
void LTPrint(LTNode* phead);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//在pos前插
void LTInsert(LTNode* pos, LTDataType x);

//判空
bool LTEmpty(LTNode* phead);

//求链长
size_t LTSize(LTNode* phead);

//销毁
void LTDestroy(LTNode* phead);

List.c

#include"list.h"

//申请一个节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

//初始化
LTNode* LTInit()
{
	LTNode* phead=BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;
	
}

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next !=phead);

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	phead->prev = tailPrev;
	tailPrev->next = phead;
	free(tail);
}

//头插
void LTPushFront(LTNode* phead,LTDataType x)
{
	assert(phead);
	LTNode* newnode=BuyLTNode(x);
	newnode->next= phead->next;
	phead->next->prev = newnode;
	phead->next= newnode;
	newnode->prev=phead;
}

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* cur = phead->next;
	LTNode* next = cur->next;
	free(cur);
	phead->next = next;
	next->prev = phead;
}

//打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

//在pos之前插入
void LTInsert(LTNode* pos,LTDataType x)
{
	assert(pos);
	
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

//删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* first = pos->prev;
	LTNode* second= pos->next;

	free(pos);
	first->next = second;
	second->prev = first;
}

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

//求链表长度
size_t LTSize(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	size_t size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

//销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);

}

Test.c

#include"list.h"

int main()
{
	LTNode* phead = LTInit();

	LTPushBack(phead, 100);
	LTPrint(phead);
	LTPopBack(phead);
	LTPrint(phead);

	LTPushFront(phead, 200);
	LTPushFront(phead, 300);
	LTPushFront(phead, 400);
	LTPrint(phead);

	LTNode* pos = LTFind(phead, 400);
	LTInsert(pos, 500);
	LTPrint(phead);

	pos = LTFind(phead, 500);
	LTErase(pos);
	LTPrint(phead);

	LTDestroy(phead);
	phead = NULL;

	return 0;
}

四、 总结

通过对单链表（不带头单向非循环链表）和带头双向循环链表的学习，我们可以发现带头双向循环链表优势更明显，虽然它看起来结构更复杂，但用起来却更方便。

星空之下-
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
带头结点的双向循环链表数据结构
01-08
【带头结点的双向循环链表数据结构】 在数据结构中，双向循环链表是一种特殊类型的数据结构，它允许从两个方向遍历链表。在本案例中，我们需要使用C++和Java分别实现这种数据结构，并确保它们符合指定的要求。 在...
【数据结构与算法】(6)：带头结点的双向循环链表
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-31 2969
带头结点的双向循环链表
数据结构——带头双向循环链表
Jambo!的博客
04-04 666
带头双向循环链表
数据结构-带头双向循环链表
m0_61433144的博客
07-18 1458
链表的种类非常丰富，有带头结点的或不带头结点的，有单向的或双向的，有循环的或非循环的，这样组合起来有2*2*2=8种链表结构。头结点与头指针的概念：不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头链表中第一个结点，该结点通常不存储数据。 引入头结点可以带来两个优点：1.由于第一个数据结点的位置被存储在头结点的指针域中，因此在链表的第一个位置上的操作和在链表其他位置上的操作一致，无须进行特殊处理。2.无论链表是否为空，其头指针都指向头结点，因此空表与非空表的处理也得到统一。........
数据结构——双向循环链表
qq_67611811的博客
08-28 2051
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
数据结构初阶--带头双向循环链表
weixin_36194037的博客
07-26 661
循环单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。与单链表类似，双链表也可增加头结点使双链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。由于在双向链表中既有前向链又有后向链，寻找任一结点的直接前驱结点与直接后继结点都变得非常方便了。//定义}LTNode;
数据结构之带头双向循环链表
qq_53822523的博客
07-14 541
熟悉的数据结构专栏上新啦~今天给大家伙带来的新品是——带头双向循环链表！
【数据结构】带头节点双向循环链表
weixin_53269843的博客
11-21 2028
顺序表和链表的区别 带头双向循环链表分析 带头双向循环链表结构： 创建一个节点 哨兵位头节点 打印链表中的值 在pos前插入 删除pos位置的节点 尾插 尾删 头插： 头删 链表元素查找
数据结构—带头双向循环链表
想要上进的coder的博客
11-05 519
一、什么是双向链表 哨兵位头结点：里面有两个指针，prev和next prev：记录前一个结点的地址 next：记录后一个结点的地址 哨兵位结点是为了方便增删查改，里面并不存储有效数据
数据结构线性表——带头双向循环链表
2303_78442132的博客
11-11 859
数据结构、线性表、双链表
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
循环链表和双向链表.ppt
09-20
循环链表和双向链表是两种特殊类型的线性链表，它们在数据结构中扮演着重要角色，尤其在处理线性关系的数据时。下面将详细讨论这些概念。 首先，我们来看带头结点的链表。在普通链表的基础上，带头结点的链表会在...
漫话数据结构-单循环链表及基本操作.pptx
11-03
对于单循环链表的优化，可以考虑使用双向循环链表，它在每个节点中增加了一个指向前一个节点的指针，进一步提高了操作效率，特别是在需要反向遍历链表的情况下。 总的来说，数据结构的选择取决于具体的应用场景。在...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 285
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 468
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 259
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
插入和选择排序
c23856的博客
07-20 498
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
java实现带头双向循环链表(附完整源码)
06-08
该代码实现了带头双向循环链表的数据结构，支持在链表末尾添加元素、在指定位置插入元素、删除指定位置的元素、获取指定位置的元素、获取链表长度等操作。在算法实现中，通过一个Node类来表示链表中的节点，包含数据...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值