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

卫卫周大胖;2024-01-06 16:51

前言：在前面我们学习了顺序表、单向链表，今天我们在单链表的基础上进一步来模拟实现一个带头双向链表。

💖 博主CSDN主页:卫卫卫的个人主页 💞

👉 专栏分类:数据结构 👈

💯代码仓库:卫卫周大胖的学习日记💫

💪关注博主和博主一起学习!一起努力！

双向链表

带头双向循环链表 ：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表(如下图所示)。通常我们会使用一个头节点head 其并不存储数据只是作为一个哨兵位的作用负责指向下一个元素。
双向链表的基本功能:

  1. 双向链表的初始化
  2. 双链表的销毁
  3. 创建一个新的节点
  4. 打印链表中的元素
  5. 双向链表尾插
  6. 双向链表尾删
  7. 双向链表头插
  8. 双向链表的头删
  9. 双链表元素查找
  10. 双向链表在pos的前面进行插入
  11. 双向链表删除pos位置的节点

双向链表的定义

c 复制代码 
//双向链表的定义
typedef int LTDatatype;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDatatype val;
}LTNode;

双向链表-创建新的节点

因为我们是动态开辟的链表，因此我们在对链表进行操作的时候，每插入一个节点时都要开辟一个节点，因此我们一样写一个接口函数来实现。
代码思路 :我们只需要直接和前面单链表一样开辟思路即可，无非我们需要多管理一个prev 指针，这里我们让其置为空即可。
代码实现：

c 复制代码 
LTNode* ListCreate(LTDatatype x)//创建一个新的节点
{
	LTNode* newnode = malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	newnode->prev = NULL;
	return newnode;
}

双向链表-初始化

代码思路 ：因为双向链表中，我们需要一个哨兵位(头节点)来管理，因此我们在初始化的时候，需要开辟一个节点作为哨兵位，然后将其的pre 和next 指针置为空即可。
代码实现:

c 复制代码 
LTNode* ListInit()//双链表的初始化
{
	LTNode* phead = ListCreate(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

双向链表-打印链表中的元素

代码思路 ：由于我们是一个循环双向链表，在前面的图可以知道，我们不能够直接通过判断尾指针是否为空指针来判定是否是链表中的尾部元素，但是我们可以知道的是：链表中的最后一个节点的下一个节点，是该链表的头部，所以我们通过判定链表中当前节点的下一个节点是不是头节点，就可以知道是否是链表的尾部了。
代码实现:

c 复制代码 
void ListPrint(LTNode* pHead)//打印链表中的元素
{
	assert(pHead);
	LTNode* cur = pHead;
	printf("哨兵位-> ");
	while (pHead != cur->next)
	{
		printf("%d->", cur->next->val);
		cur = cur->next;
	}
	printf("\n");

双向链表-尾插

代码思路 :由于双向循环链表的特性，我们可以知道哨兵位的pre指向的是尾部节点，因此我们在尾插的时候不用特意的去寻找尾节点，我们只需要，用哨兵位的前驱指针找到尾部节点，让其指向新开辟的空间。因此：

  1. 通过哨兵位的前驱指针找到尾部节点
  2. 让尾部节点指向新开辟的空间。
  3. 让新开辟的空间的前驱指针指向原理的尾部节点，再让其尾指针指向头节点，即可完成双向链表的尾插。(如下图所示)

函数实现：

c 复制代码 
void ListPushBack(LTNode* pHead, LTDatatype x)//双向链表尾插
{
	assert(pHead);
	LTNode* newnode = ListCreate(x);
	LTNode* cur = pHead->prev;//尾结点
	pHead->prev = newnode;
	newnode->next = pHead;
	newnode->prev = cur;
	cur->next = newnode;
}

函数测试:

c 复制代码 
void Test_ListPushBack()
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	ListPrint(sl);
}

运行结果 :

双向链表-尾删

代码思路:这里我们依然要重复利用刚刚说到的循环双链表的性质，我们直接通过哨兵位的前驱指针来找到尾结点，来帮助我们进行尾删。

  1. 通过哨兵位前驱指针找到尾节点
  2. 找到尾结点的前驱指针，即倒数第二个节点，让其指向头节的前驱指针指向倒数第二个节点。
  3. 此时在将倒数第二个节点的尾部节点指向头节点，即可完成尾删，此时在释放掉原本的尾部节点即可。(如下图所示)

代码实现:

c 复制代码 
void ListPopBack(LTNode* pHead)//双向链表尾删
{
	assert(pHead);
	assert(pHead->next);
	LTNode* tail = pHead->prev;//尾部节点
	pHead->prev = tail->prev;//让头节点指向倒数第二个节点
	tail->prev->next = pHead;//尾部节点指向头节点
	free(tail);
	tail = NULL;
}

函数测试:

c 复制代码 
void Test_ListPopBack()//双向链表尾删
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("删除前\n");
	ListPrint(sl);
	ListPopBack(sl);
	printf("删除后\n");
	ListPrint(sl);
}

运行结果 :

双向链表-头插

代码思路:

  1. 我们将哨兵位的next指针指向新开辟的节点。
  2. 将新节点的前驱指针指向原本的哨兵位
  3. 将新节点的next指向原本的第二个节点
  4. 将原本的第二个节点的前驱指针指向新节点，即可完成头插。(如下图)

代码实现:

c 复制代码 
void ListPushFront(LTNode* pHead, LTDatatype x)//双向链表头插
{
	assert(pHead);
	LTNode* newnode = ListCreate(x);
	LTNode* tail = pHead->next;//记录头节点的下一个节点的位置
	pHead->next = newnode;//让头节点的下一个节点指向新节点
	newnode->prev = pHead;//让新节点的前驱指针指向头节点
	tail->prev = newnode;//让原本的第二个节点的前驱指针指向newnode
	newnode->next = tail;//新节点的尾部节点指针原本的第二个节点
}

函数测试:

c 复制代码 
void Test_ListPushFront()//双向链表头插
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("头插前\n");
	ListPrint(sl);
	printf("头插后\n");
	ListPushFront(sl, 10);
	ListPrint(sl);
}

运行结果 ：

双向链表-头删

代码思路:

  1. 我们直接通过哨兵位找到头节点，然后将哨兵位的后驱指针指向头节点的下一个节点。
  2. 将头节点的下一个节点的前驱指针指向哨兵位
  3. 在将原本的头节点释放掉即可完成头删（如下图）

代码实现:

c 复制代码 
void ListPopFront(LTNode* pHead)//双向链表的头删
{
	assert(pHead);
	assert(pHead->next);
	LTNode* tail = pHead->next;
	pHead->next = tail->next;//找到第二个节点指向哨兵位后驱指针
	tail->next->prev = pHead;//让次节点指向哨兵位
	free(tail);
	tail = NULL;
}

函数测试:

c 复制代码 
void Test_ListPopFront()//双向链表的头删
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("头删前\n");
	ListPrint(sl);
	printf("头删后\n");
	ListPopFront(sl);
	ListPrint(sl);
}

运行结果 :

双向链表-元素查找

代码思路:

  1. 这里我们依然通过双向链表的性质来帮助我们判断是否走到了链表尾部。
  2. 我们定义一个cur指针去帮助我们查找
  3. 当cur碰到了尾部的时候说明查找完了，如果此时还没找到就返回空即可
  4. 在查找的过程中碰到了要查找的值直接返回此时cur 的地址即可。(如下图)

代码实现:

c 复制代码 
LTNode* ListFind(LTNode* pHead, LTDatatype x)//双链表查找
{
	assert(pHead);
	LTNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

函数测试：

c 复制代码 
void Test_ListFind()//双向链表的查找
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("%p\n", ListFind(sl, 2));
	printf("%p\n", ListFind(sl, 999));
}

运行结果 :

双向链表-在pos的前面进行插入

代码思路:

  1. 我们找到要插入的pos 的前一个节点，让其的next指向新开辟的节点
  2. 在让此时pos前驱指针所在的位置指向新开辟的节点
  3. 再让原本插入的节点的next指向新开辟的节点
  4. 再让新开辟的节点的前驱指针和next 分别指向原本pos 的前一个节点和指向pos。（如下图）


代码实现:

c 复制代码 
void ListInsert(LTNode* pos, LTDatatype x)// 双向链表在pos的前面进行插入
{
	LTNode* newnode = ListCreate(x);
	LTNode* cur = pos->prev;//找到pos前的一个节点
	pos->prev = newnode;//让其前一个结点指向新结点
	cur->next = newnode;
	newnode->prev = cur;
	newnode->next = pos;
}

函数测试:

c 复制代码 
void Test_ListInsert()
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("插入前\n");
	ListPrint(sl);
	ListInsert(ListFind(sl, 2), 99);
	printf("插入后\n");
	ListPrint(sl);
}

运行结果 :

双向链表-删除pos所在的位置

代码思路:

  1. 我们找到pos 所在位置的下个一个节点让其指向pos所在位置的前一个结点
  2. 此时在释放掉pos所在的位置即可完成删除

代码实现:

c 复制代码 
void ListErase(LTNode* pos)// 双向链表删除pos位置的节点
{
	assert(pos);
	LTNode* tail = pos->next;
	tail->prev = pos->prev;
	pos->prev->next = tail;
	free(pos);
	pos = NULL;
}

函数测试:

c 复制代码 
void Test_ListErase()
{
	LTNode* sl = ListInit();
	ListPushBack(sl, 5);
	ListPushBack(sl, 2);
	ListPushBack(sl, 1);
	ListPushBack(sl, 8);
	printf("删除前\n");
	ListPrint(sl);
	printf("删除后\n");
	ListErase(ListFind(sl, 2));
	ListPrint(sl);
}

运行结果 :

双向链表-链表的销毁

关于双向链表的销毁这里就不做过多的总结了，这个和前面的打印元素有比较像，因此不懂的可以参考一下即可。
代码实现:

c 复制代码 
void ListDestory(LTNode* pHead)//双链表的销毁
{
	assert(pHead);
	LTNode* cur = pHead->next;
	
	while (pHead != cur)
	{
		LTNode* tail = cur->next;
		free(cur);
		cur = tail;
	}
	free(pHead);

}

总结

到这里我们可以发现，当我们写了一个插入之后会发现，那双向链表的头插和尾插，我们可以直接用我们刚刚写的插入的函数直接来实现，就完全没必要单独写尾插和头插了，至于为什么放在最后才说，是因为作者想和大家一起锻炼一下自己的思维能力，这里直接放代码就不演示了。

c 复制代码 
void ListPushBack(LTNode* pHead, LTDatatype x)//双向链表尾插
{
	assert(pHead);
	ListInsert(pHead,x);//直接再phead之前插入即可
}

void ListPushFront(LTNode* pHead, LTDatatype x)//双向链表头插
{
	assert(pHead);
	ListInsert(pHead->next, x);
}

结语：今天的内容就到这里吧，谢谢各位的观看，如果有讲的不好的地方也请各位多多指出，作者每一条评论都会读的，谢谢各位。

🫵🫵🫵 这里提前祝各位新年快乐呀！ 💞

相关推荐
lb36363636362 小时前
分享一下arr的意义(c基础)(必看)(牢记)
c语言·知识点
南东山人4 小时前
一文说清：C和C++混合编程
c语言·c++
stm 学习ing4 小时前
FPGA 第十讲 避免latch的产生
c语言·开发语言·单片机·嵌入式硬件·fpga开发·fpga
茶猫_9 小时前
力扣面试题 - 25 二进制数转字符串
c语言·算法·leetcode·职场和发展
ö Constancy9 小时前
Linux 使用gdb调试core文件
linux·c语言·vim
lb36363636369 小时前
介绍一下strncmp(c基础)
c语言·知识点
wellnw9 小时前
[linux] linux c实现共享内存读写操作
linux·c语言
Hera_Yc.H10 小时前
数据结构之一：复杂度
数据结构
肥猪猪爸11 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
linux_carlos11 小时前
环形缓冲区
数据结构
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10你还在傻傻的打开页面输用户名和密码？来我教你实现自动化