【初阶数据结构】带头双向循环链表讲解

已于 2024-05-15 17:12:58 修改
阅读量1.2k 收藏 19
点赞数 39
分类专栏： 初阶数据结构 文章标签： 链表 数据结构
于 2024-05-15 16:25:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s1mplewo/article/details/138908231
版权

前言 

📚作者简介：爱编程的小马，正在学习C/C++，Linux及MySQL。

📚本文收录与初阶数据结构系列，本专栏主要是针对时间、空间复杂度，顺序表和链表、栈和队列、二叉树以及各类排序算法，持续更新！

📚相关专栏C++及Linux正在发展，敬请期待！

1. 带头双向循环链表的实现

1.1  概念

之前我给大家讲过不带头单向不循环链表，这次我再给大家介绍一个也同样很重要的，叫做带头双向循环链表。

带头双向循环链表，顾名思义，就是带哨兵位，有前后指针，有循环的链表。 

结构如下：

1.2 链表的实现

1.2.1 链表的基本搭建 

typedef int LTtypeData;


typedef struct LTNode
{
	struct LTNode* prev;
	struct LTNode* next;
	LTtypeData data;

}LTNode;

首先，双向表示需要两个指针，一个是prev指针，可以找到前一个结点，一个是next指针，可以找到下一个结点，还有一个data来存放数据。

1.2.2 结点动态内存开辟的函数 

这个地方很重要，因为后面基本都是要通过这个函数来申请结点， 

LTNode* BuyLTNode(LTtypeData x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

1.2.3 链表的初始化 

链表的初始化其实很简单，申请一个结点，然后让结点自己指向自己，构成循环。看下图

代码实现：

LTNode* LTcreate()
{
	LTNode* phead = BuyLTNode(-1);
	assert(phead);
	phead->prev = phead;
	phead->next = phead;
	return phead;
}

为什么要返回结构体指针？因为外面结构体指针想改变，是不是要么就是传外面结构体的地址，要么就是带返回值，很明显后者更简单。

1.2.4 链表的打印 

这个带循环的链表就不是到空指针就结束这么判断了，而是不等于头结点就继续，等于是不是代表已经循环完一圈了，就结束。

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

1.2.5 链表的尾插 

尾插需不需要像单链表一样找尾， 是不是不需要啊？哪里是尾？是不是phead->prev是尾，看图

代码实现：

void LTPushBack(LTNode* phead, LTtypeData x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;
	newnode->prev = tail;
	tail->next = newnode;
	phead->prev = newnode;
	newnode->next = phead;
}

首先我们先创建一个newnode新节点，要尾插的结点，然后将尾部和新结点相连接是不是就可以了，在把新结点和头结点相连接是不是就尾插成功了？

1.2.6 链表的头插

头插怎么做？是不是需要找到phead，和记录phead的next，也就是下一个，然后让newnode结点和phead与next相连接就ok。

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

 1.2.7 链表的尾删

删除要特别注意，链表为空就不要删了。还需不需要像单链表一样找尾，再找尾的前一个？不需要，看图：

代码实现： 

void LTPopBack(LTNode* phead)
{
	assert(phead);
	//没有再删是要出问题的
	assert(!IsEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);
	phead->prev = tailPrev;
	tailPrev->next = phead;
}

在这里介绍一下这个bool函数，这个可以表示是真还是假，那么函数设置

bool IsEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

这个代码的意思是，如果返回值是真，说明一件事，就是确实是空链表，那assert断言的时候加一个逻辑非即可表示false，便于我们判断是不是空链表。 

1.2.8 链表的头删

这个就很简单了，找到链表的下一个和下下一个，让链表指向下下一个结点即可，看图：

 代码实现：

void LTPopFront(LTNode* phead)
{
	//方法一 一个指针
	assert(phead);
	assert(!IsEmpty(phead));
	LTNode* next = phead->next;
	phead->next = next->next;
	next->next->prev = phead;
}

1.2.9 链表的查找 

这个就更加的简单了，输入要找的值，返回这个地方的结构体指针就ok

LTNode* LTFind(LTNode* phead, LTtypeData x)
{
	assert(phead);
	assert(!IsEmpty(phead));

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

1.2.10 链表的任意位置前插

 

在pos前插，是不是需要找到pos前面的位置，互相链接即可。

void ListInsert(LTNode* pos, LTtypeData x)
{
	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;
}

那么我就问大家两个问题，如何用任意位置的前插来表示头插和尾插？

首先来讲下头插：

头插是不是传phead->next是不是就可以啊，为什么？ 

这个是标准的头插。

2、尾插传什么参数？

尾插是不是要找尾，谁的prev是尾，是不是phead，是不是传phead就可以了？是的。

1.2.11 链表在指定位置的删除 

是不是很简单，为什么？因为找指定位置的前一个和后一个，最后链接起来是不是就可以了？ 

void ListErase(LTNode* pos)
{
	assert(pos);
	assert(!IsEmpty(pos));
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	free(pos);
	posprev->next = posnext;
	posnext->prev = posprev;
}

调用这个函数，如何实现尾删和头删？

尾删：是不是传phead->prev就可以？是的

头删：是不是传phead->next就可以 ？是的

1.2.12 释放链表 

 这个就是和单链表相同，一前一后指针即可。

void Destory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

2. 完整代码 

2.1 List.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

LTNode* BuyLTNode(LTtypeData x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

bool IsEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

LTNode* LTcreate()
{
	LTNode* phead = BuyLTNode(-1);
	assert(phead);
	phead->prev = phead;
	phead->next = phead;
	return phead;
}

void LTPushBack(LTNode* phead, LTtypeData x)
{
	assert(phead);
	/*LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;
	newnode->prev = tail;
	tail->next = newnode;
	phead->prev = newnode;
	newnode->next = phead;*/
	ListInsert(phead, x);
}

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

void LTPushFront(LTNode* phead, LTtypeData x)
{
	assert(phead);
	/*LTNode* newnode = BuyLTNode(x);
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;*/
	ListInsert(phead->next, x);

}


void LTPopBack(LTNode* phead)
{
	assert(phead);
	//没有再删是要出问题的
	assert(!IsEmpty(phead));
	/*LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);
	phead->prev = tailPrev;
	tailPrev->next = phead;*/
	ListErase(phead->prev);
}

void LTPopFront(LTNode* phead)
{
	//方法一 一个指针
	assert(phead);
	assert(!IsEmpty(phead));
	/*LTNode* next = phead->next;
	phead->next = next->next;
	next->next->prev = phead;*/
	ListErase(phead->next);
}



LTNode* LTFind(LTNode* phead, LTtypeData x)
{
	assert(phead);
	assert(!IsEmpty(phead));

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

void ListInsert(LTNode* pos, LTtypeData x)
{
	assert(pos);
	LTNode* posprev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListErase(LTNode* pos)
{
	assert(pos);
	assert(!IsEmpty(pos));
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	free(pos);
	posprev->next = posnext;
	posnext->prev = posprev;
}

void Destory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

2.2 List.h

#pragma once

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


typedef int LTtypeData;


typedef struct LTNode
{
	struct LTNode* prev;
	struct LTNode* next;
	LTtypeData data;

}LTNode;

//创建新结点
LTNode* LTcreate();

//判断是否没有数据
bool IsEmpty(LTNode* phead);
//开始插入数据了
//尾插
void LTPushBack(LTNode* phead, LTtypeData x);

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

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

//头删
void LTPopFront(LTNode* phead);
//打印数据
void LTPrint(LTNode* phead);

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

//在pos前面进行插入
void ListInsert(LTNode* pos, LTtypeData x);

//删除pos位置的值

void ListErase(LTNode* pos);

//销毁链表
void Destory(LTNode* phead);

2.3 test.c  

这个就留给大家自己去测试函数了。

总结

1、大家一定要自己来写一下带头双向循环链表，因为真的很实用而且很简单

2、下一节给大家更新栈和队列

 如果这份博客对大家有帮助，希望各位给小马一个大大的点赞鼓励一下，如果喜欢，请收藏一下，谢谢大家！！！
制作不易，如果大家有什么疑问或给小马的意见，欢迎评论区留言

爱编程的小马.
关注
  • 39
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
【数据结构初阶】图解链表（二）双向带头循环链表
Bitdancing的专栏
10-30 703
单链表在之前的博客里已经详细讲解过了 （指路导航 无哨兵位单向非循环链表），接下来讲解的是 双向带头循环链表。 源码地址链接 一级指针还是二级指针？ 首先我们要确定的问题是带哨兵位的链表，需要传啥类型的实参？ 由图见，因为带哨兵位，不对phead进行修改，所以只需要传一级指针。 结点结构体 // 带头+双向+循环链表增删查改 typedef int LTDataType; typedef struct ListNode { LTDataType data; struct ListNode* next
数据结构与算法初阶4：链表—带头双向循环链表知识讲解
King_lm_Guard的博客
07-08 437
数据结构与算法初阶篇：带头双向循环链表相关知识讲解。
【数据结构初阶】复杂链表复制+带头双向循环链表+缓存级知识
The porters of knowledge
11-09 1041
经典的链表结构，值得你端详一下
【初阶数据结构】——带头双向循环链表（C描述）
m0_70980326的博客
11-21 1222
带头双向循环链表详解
数据结构初阶--双向循环链表（讲解+类模板实现）
sinat_40572875的博客
11-30 401
看下面的图，就是我今天要给大家分享有结构——带头双向循环链表。这里的头是不存放任何数据的，就是一个哨兵卫的头结点。
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回...
【数据结构】图论——AOV和AOE（拓扑排序、存放表达式、关键活动、关键路径）
ChenZHIHAO_y的博客
06-04 1053
图论——AOV和AOE（拓扑排序、存放表达式、关键活动、关键路径）
【数据结构】穿梭在二叉树的时间隧道：顺序存储的实现
萌新的博客
06-04 2191
之前我们谈过了树的存储结构，并且谈到了顺序存储结构对树这种一对多的关系结构实现起来还是比较困难的。但二叉树是一种特殊的树，由于二叉树的特殊性，使得它可以使用顺序存储结构来实现，二叉树的顺序存储结构就是使用一维数组存储二叉树中的节点，并且节点的存储位置，也就是数组的下标要能体现出来节点之间的逻辑关系
freertos中的链表1 - 链表的数据结构
dmf_fff的博客
06-07 459
在初始化链表时，xListEnd（类型为 MiniListItem_t）的 xItemValue 被设置为 portMAX_DELAY，并且 pxNext 和 pxPrevious 都指向自身，形成一个环形链表。
数据结构~~排序
2301_78029441的博客
06-07 1270
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
数据结构（树）
lazy_girl_666的博客
06-07 318
原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点。原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右节点。如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点（Nil）是黑色的；步骤： 1） 把不平衡的点作为支点，把支点左旋降级，变成左子结点，晋升原来的右子节点。对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。当根节点左子树的左子树有节点插入，导致二叉树不平衡。
希尔排序-插入排序
2301_81336748的博客
06-02 370
通过设计gap这一个变量,我们可以渐渐把无序的数组变成一个无限接近有序的数组,此时我们再来一次插入排序,就变得很简单了。来看极端情况arr[]={0,1,2,3,4,5,6,7,8,9},此时只需要遍历一遍数组时间复杂度达到了。为什么只需要遍历到倒数第二个元素,因为我们需要进行比较的是遍历到的元素的下一位值,:gap相对数组个数越大,大的数可以越快跳到后面,但是越不接近有序。gap相对数组个数越大,大的数可以越快跳到后面,但是越不接近有序。arr[]={9,8,7,6,5,4,3,2,1,0},属于。
OpenCV的核心数据结构
heeheeai的博客
06-02 435
Scalar类在OpenCV中用于表示多通道值的类，经常用于表示颜色、权重或其他多维数据。它是一个简单的四元素容器（包含四个double类型的值），可以表示不同颜色通道的值，如BGR颜色（蓝、绿、红）或者灰度值。DMatch类在OpenCV中用于表示描述符匹配中的一个匹配对，是特征匹配算法的核心部分。这些类用于表示二维和三维空间中的点。Point类通常用于整数坐标，Point2f和Point3f则用于浮点数坐标。Size类用于表示图像的尺寸，包含宽度和高度两个属性。Scalar类的主要属性和方法。
数据结构之初始泛型
我要学编程的博客
06-04 1101
深入了解包装类：拆箱与装箱 泛型的语法、使用、上界、编译、占位符、泛型方法
数据结构（C语言）之对归并排序的介绍与理解
最新发布
2401_82648291的博客
06-07 482
对归并排序简单理解望有帮助
LinkedList详解(含数据结构动画演示)
落日的博客
06-07 352
/ 获取链表的最后一个节点，赋值给变量 l// 如果链表为空，即最后一个节点为 null，抛出 NoSuchElementException 异常// 调用 unlinkLast 方法，从链表中移除最后一个节点// 确保 l 是最后一个节点且不为 null 的断言，注释掉的是因为在实际代码中没有执行断言检查的需要= null;// 保存最后一个节点的值// 保存最后一个节点的前一个节点// 将最后一个节点的值设为 null，帮助垃圾回收。
数据结构-双向循环链表
10-23
双向循环链表是一种链式存储结构，它的每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。与单向链表不同的是，双向循环链表的尾节点的后继节点指向头节点，头节点的前驱节点指向尾节点，形成一个环形结构。这种结构的好处是可以方便地在链表中进行前后遍历，而不需要像单向链表那样记录前驱节点。在双向循环链表中，插入和删除操作比较灵活，可以在任意位置进行操作。 双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向循环链表的插入操作包括在链表头插入、在链表尾插入和在链表中间插入三种情况。删除操作也包括在链表头删除、在链表尾删除和在链表中间删除三种情况。在进行插入和删除操作时，需要注意指针的指向关系，以保证链表的正确性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值