【数据结构初阶】链表（下）——带头双向循环链表的实现

已于 2023-01-23 10:13:24 修改
阅读量329 收藏 4
点赞数 8
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-11-07 18:44:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70811813/article/details/127733463
版权

目录

带头双向循环链表的实现

        1.带头双向循环链表的节点类型

        2.创建带头双向循环链表的节点

        3.向带头双向循环链表中插入数据

                <3.1>从链表尾部插入数据

                <3.2>从链表头部插入数据

                <3.3>从链表某个节点前插入数据

        4.从带头双向循环链表中删除数据

                <4.1>从链表的尾部删除数据

                <4.2>从链表的头部删除数据

                <4.3>删除链表某个节点

        5.在带头双向循环链表中查找数据

        6.遍历带头双向循环链表

        7.销毁带头双向循环链表

带头双向循环链表实现总代码

测试

        1.测试代码

        2.测试效果

 链表总结

        无头单向非循环链表和带头双向循环链表的对比

        链表和顺序表的对比

本期博客我们来对最复杂的带头双向循环链表结构进行实现：

我们可以看到该种链表比单链表多了一个头节点（head（该节点一般不存放数据））和一个指向前一个节点的指针，该种类型的链表有着比单链表更多的优势，更适合来存储数据。

带头双向循环链表的实现

        1.带头双向循环链表的节点类型

在实现该链表之前我们先要确定节点类型：

typedef int LTDataType;//数据类型
typedef struct ListNode//节点类型
{
	LTDataType _data;
	struct ListNode* _next;//指向后一个节点的指针
	struct ListNode* _prev;//指向前一个节点的指针
}ListNode;

注：这里的对int类型进行重定义是为了我们更好的看懂Data只是一种数据而不仅仅是int类型。所以我们在使用链表时存储的数据并不限制于int类型，这里仅仅是举例。

        2.创建带头双向循环链表的节点

ListNode* ListCreate()
{
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//向堆区申请一个节点大小的空间
	if (NewNode == NULL)//判断申请是否成功
	{
		perror("malloc");
		exit(-1);
	}
	NewNode->_next = NewNode;
	NewNode->_prev = NewNode;//将_next和_prev指针设为NewNode可以方便直接创建一个头节点
	return NewNode;//返回的指针的_next和_prev可以后期根据需要修改
}

        3.向带头双向循环链表中插入数据

                <3.1>从链表尾部插入数据

void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* temp = pHead;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表的末尾的过程：
	newnode->_prev = temp->_prev;//将新节点_prev指针指向链表中最后一个节点
	newnode->_next = pHead;//将新节点_next指针指向链表中的头节点
	temp->_prev->_next = newnode;//将链表中最后一个节点的_next指向新节点
	temp->_prev = newnode;//将头节点的_prev指针指向新节点
}

                <3.2>从链表头部插入数据

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* temp = pHead;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表的头部的过程：
	newnode->_prev = temp;//将新节点_prev指针指向链表中头节点
	newnode->_next = temp->_next;//将新节点_next指针指向链表中的第一个数据节点
	temp->_next->_prev = newnode;//将链表中第一个数据节点的_perv指向新节点
	temp->_next = newnode;//将头节点的_next指针指向新节点
}

                <3.3>从链表某个节点前插入数据

void ListInsert(ListNode* pos, LTDataType x)//pos传入将要插入其前的节点
{
	assert(pos);//传入的节点不能为空
	ListNode* temp = pos;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表pos节点前的过程：
	newnode->_prev = temp->_prev;//将新节点_prev指针指向pos节点的前一个节点
	newnode->_next = temp;//将新节点_next指针指向pos节点
	temp->_prev->_next = newnode;//将pos前一个节点的_next指针指向新节点
	temp->_prev = newnode;//将pos节点的_prev指针指向新节点
}

        4.从带头双向循环链表中删除数据

                <4.1>从链表的尾部删除数据

void ListPopBack(ListNode* pHead)
{
	assert(pHead);//传入的头节点不能为空
	assert(pHead->_prev);//链表不能为空
	ListNode* Del = pHead->_prev;
	//下面是将最后一个数据节点删除过程：
	Del->_prev->_next = Del->_next;//将最后一个数据节点的上一个节点的_next指针指向头节点
	Del->_next->_prev = Del->_prev;//将头节点的_next指针指向最后一个数据节点的上一个节点
	free(Del);//释放最后一个数据节点的空间
	Del = NULL;//防止野指针的产生
}

                <4.2>从链表的头部删除数据

void ListPopFront(ListNode* pHead)
{
	assert(pHead);//传入的头节点不能为空
	assert(pHead->_next);//链表不能为空
	ListNode* Del = pHead->_next;
	//下面是将第一个数据节点删除过程：
	Del->_next->_prev = Del->_prev;//将第一个数据节点的下一个节点的_prev指针指向头节点
	Del->_prev->_next = Del->_next;//将头节点的_next指针指向第一个数据节点的下一个节点
	free(Del);//释放第一个数据节点的空间
	Del = NULL;//防止野指针的产生
}

                <4.3>删除链表某个节点

void ListErase(ListNode* pos)//pos传入要删除的节点
{
	assert(pos);//传入的节点不能为空
	ListNode* Del = pos;
	//下面是将pos数据节点删除过程：
	Del->_prev->_next = Del->_next;//将pos数据节点的前一个节点的_next指针指向pos数据节点的下一个节点
	Del->_next->_prev = Del->_prev;//将pos数据节点的下一个节点的_prev指针指向pos数据节点的上一个节点
	free(Del);//释放pos数据节点的空间
	Del = NULL;//防止野指针的产生
}

        5.在带头双向循环链表中查找数据

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* find = pHead->_next;//跳过头节点开始查找
	while (find != pHead)
	{
		if (find->_data == x)
			return find;//找到返回该节点
		find = find->_next;
	}
	return NULL;//没找到返回空指针
}

        6.遍历带头双向循环链表

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	printf("Head->");
	ListNode* print = pHead->_next;//跳过头节点开始打印
	while (print != pHead)
	{
		printf("%d->", print->_data);
		print = print->_next;
	}
	printf("Head\n");
}

        7.销毁带头双向循环链表

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* Del = pHead->_next;//跳过头节点开始删除节点
	ListNode* temp = Del;
	while (Del != pHead)
	{
		temp = temp->_next;
		free(Del);
		Del = temp;
	}
	pHead->_next = pHead;
	pHead->_prev = pHead;//将链表置空
}

带头双向循环链表实现总代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

ListNode* ListCreate()
{
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//向堆区申请一个节点大小的空间
	if (NewNode == NULL)//判断申请是否成功
	{
		perror("malloc");
		exit(-1);
	}
	NewNode->_next = NewNode;//防止野指针的产生
	NewNode->_prev = NewNode;//防止野指针的产生
	return NewNode;
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* temp = pHead;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表的末尾的过程：
	newnode->_prev = temp->_prev;//将新节点_prev指针指向链表中最后一个节点
	newnode->_next = temp;//将新节点_next指针指向链表中的头节点
	temp->_prev->_next = newnode;//将链表中最后一个节点的_next指向新节点
	temp->_prev = newnode;//将头节点的_prev指针指向新节点
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* temp = pHead;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表的头部的过程：
	newnode->_prev = temp;//将新节点_prev指针指向链表中头节点
	newnode->_next = temp->_next;//将新节点_next指针指向链表中的第一个数据节点
	temp->_next->_prev = newnode;//将链表中第一个数据节点的_perv指向新节点
	temp->_next = newnode;//将头节点的_next指针指向新节点
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);//传入的节点不能为空
	ListNode* temp = pos;
	ListNode* newnode = ListCreate();//申请一个新节点
	newnode->_data = x;//存入数据
	//下面是将新节点插入到链表pos节点前的过程：
	newnode->_prev = temp->_prev;//将新节点_prev指针指向pos节点的前一个节点
	newnode->_next = temp;//将新节点_next指针指向pos节点
	temp->_prev->_next = newnode;//将pos前一个节点的_next指针指向新节点
	temp->_prev = newnode;//将pos节点的_prev指针指向新节点
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);//传入的头节点不能为空
	assert(pHead->_prev);//链表不能为空
	ListNode* Del = pHead->_prev;
	//下面是将最后一个数据节点删除过程：
	Del->_prev->_next = Del->_next;//将最后一个数据节点的上一个节点的_next指针指向头节点
	Del->_next->_prev = Del->_prev;//将头节点的_next指针指向最后一个数据节点的上一个节点
	free(Del);//释放最后一个数据节点的空间
	Del = NULL;//防止野指针的产生
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);//传入的头节点不能为空
	assert(pHead->_next);//链表不能为空
	ListNode* Del = pHead->_next;
	//下面是将第一个数据节点删除过程：
	Del->_next->_prev = Del->_prev;//将第一个数据节点的下一个节点的_prev指针指向头节点
	Del->_prev->_next = Del->_next;//将头节点的_next指针指向第一个数据节点的下一个节点
	free(Del);//释放第一个数据节点的空间
	Del = NULL;//防止野指针的产生
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);//传入的节点不能为空
	ListNode* Del = pos;
	//下面是将pos数据节点删除过程：
	Del->_prev->_next = Del->_next;//将pos数据节点的前一个节点的_next指针指向pos数据节点的下一个节点
	Del->_next->_prev = Del->_prev;//将pos数据节点的下一个节点的_prev指针指向pos数据节点的上一个节点
	free(Del);//释放pos数据节点的空间
	Del = NULL;//防止野指针的产生
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);//传入的头节点不能为空
	ListNode* find = pHead->_next;//跳过头节点开始查找
	while (find != pHead)
	{
		if (find->_data == x)
			return find;//找到返回该节点
		find = find->_next;
	}
	return NULL;//没找到返回空指针
}
// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	printf("Head->");
	ListNode* print = pHead->_next;//跳过头节点开始打印
	while (print != pHead)
	{
		printf("%d->", print->_data);
		print = print->_next;
	}
	printf("Head\n");
}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* Del = pHead->_next;//跳过头节点开始删除节点
	ListNode* temp = Del;
	while (Del != pHead)
	{
		temp = temp->_next;
		free(Del);
		Del = temp;
	}
	pHead->_next = pHead;
	pHead->_prev = pHead;
}

测试

        1.测试代码

int main()
{
	ListNode* Head= ListCreate();
	ListPrint(Head);
	ListPushBack(Head, 1);
	ListPrint(Head);
	ListPushBack(Head, 2);
	ListPrint(Head);
	ListPushBack(Head, 3);
	ListPrint(Head);
	ListPushBack(Head, 4);
	ListPrint(Head);
	ListPushFront(Head, 5);
	ListPrint(Head);
	ListInsert(ListFind(Head, 5), 6);
	ListPrint(Head);
	ListPopFront(Head);
	ListPrint(Head);
	ListPopFront(Head);
	ListPrint(Head);
	ListPopBack(Head);
	ListPrint(Head);
	ListErase(ListFind(Head, 2));
	ListPrint(Head);
	ListDestory(Head);
	ListPrint(Head);
	return 0;
}

        2.测试效果


 
链表总结

        无头单向非循环链表和带头双向循环链表的对比

        在我们实现完无头单向非循环链表和带头双向循环链表之后发现带头双向循环链表虽然结构复杂但是在尾插尾删时不用遍历整个链表，并且在实际使用时也比单链表更方便操作，具有绝对的优势，所以在存储数据时尝尝使用的是带头双向循环链表。

        链表和顺序表的对比

存储空间上：              顺序表物理空间上一定连续。

                                    链表在逻辑上连续，但在物理空间上不一定连续（具体要看malloc函数的分配了）。

在访问数据时：           顺序表可以随机访问，时间复杂度为O(1)。

                                    链表不可以随机访问，时间复杂度为O(N)。

在插入(删除)数据时： 顺序表可能需要移动元素，效率低，时间复杂度为O(N)。

                                    链表只需要改变指针指向，效率高，时间复杂度为O(N)。

添加数据时：              动态顺序表可能需要扩容。

                                   链表添加一个数据开辟一块空间没有扩容概念。

应用场景：                 顺序表一般运用在元素高效存储和频繁访问的场景。

                                   链表一般运用在任意位置插入和删除频繁的场景。

缓存利用率：             顺序表开辟的空间全部都用来存储数据，利用率高。

                                   链表开辟的一部分空间用来存储指针，利用率低。

数据结构的初阶链表到这里就结束了，代码量较多难免会有不足之处，还请各位大佬在评论区赐教！

各位看客咱们下一期见~

1e-12
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上...
数据结构-带头双向循环链表的基本实现（C语言，简单易懂，含全部代码）
阿龙的博客
04-26 2196
【数据结构基础入门】带头双向循环链表的概念、结构和接口实现
数据结构之带头双向循环链表的实现
Ly的博客
11-08 475
数据结构之带头双向循环链表的实现
【c语言实现带头双向循环链表】
小小太空人的博客
03-13 1912
带头双向循环链表相比于单链表结构较复杂，但是它用代码实现起来却较容易，先来介绍它的结构。 一个节点里存上驱和下驱指针还有数据，头节点的上驱指针指向尾节点，尾节点的下驱指针指向头节点，然后他们之间进行双向互链，构成带头双向循环链表。 正是因为它这种巧妙的结构设计，不用像单链表需遍历去找上一个节点的地址，所以它在进行各种操作的时候容易实现，并且它的前增，尾增等操作的时间复杂度都是O（1）。 链表的结构体（前面有介绍） typedef struct DList...
双向带头循环链表详解-＞附c语言创建链表代码
c-and-c++ It*s my life
01-19 675
双向带头循环链表实现，好兄弟，速看速掌握，附详细代码
初阶数据结构——线性表——链表——带头双向循环链表
dtxew love c++
10-28 2643
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 ????????博主的微信公众号关注啦，关注我每天学习一道题，点我关注 前言 其中在链表的实现中有很多种实现方法，主要取决于以下几个因素 单向还是双向？ 循环还是不循环？ 带头还是不带头 这几个特征两两组合，就可以看做一种链表的
JavaScript数据结构之双向链表和双向循环链表的实现
01-19
双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素。 双向链表提供了两种迭代列表的方法：从头到尾，或者反...
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
堆的实现与堆排序
酷酷学!!!的博客
05-19 1148
本篇旨在介绍二叉树中特殊结构堆, 以及堆的实现与应用更多文章 博客主页:酷酷学!!!点击关注 一起加油~int _size;}Heap;// 堆的销毁// 堆的插入// 堆顶数据的删除// 取堆顶的数据// 堆的数据个数// 堆的判空任意节点的值大于或等于其子节点的值（大顶堆）或小于或等于其子节点的值（小顶堆）。二叉树堆是一个完全二叉树，即除了最后一层外，其他层都是满的，并且最后一层的节点都靠左排列。
数据结构-线段树
knoci的博客
05-19 1008
线段树（Segment Tree）是一种数据结构，它主要用于维护区间信息（要求满足结合律），它可以实现 𝑂(log⁡𝑛) 的区间修改，还可以同时支持多种操作（加、乘）。从数据结构的角度来说，线段树是用一个完全二叉树来存储对应于其每一个区间（segment）的数据。该二叉树的每一个结点中保存着相对应于这一个区间的信息。同时，线段树所使用的这个二叉树是用一个数组保存的，与堆（Heap）的实现方式相同。例如，给定一个长度为N的数组arr，其所对应的线段树TT的根结点代表整个数组所在的区间对应的信息，及。
数据结构_栈和队列学习
weixin_46571256的博客
05-19 459
简单易实现，空间固定，可能造成空间浪费或溢出。：检查栈顶指针是否为NULL。
数据结构（链表）
wan__cheng的博客
05-19 460
存储空间上 物理上一定连续 逻辑上连续，但物理上不一定连续。插入 动态顺序表，空间不够时需要扩容 没有容量的概念。概念：链表是一种物理上不连续，非顺序的存储结构，数据元素的逻辑顺序上是通过指针来连接的线性表。任意位置插入或者删除元素 可能需要搬移元素，效率低O(N) 只需修改指针指向。
哈希表---闭散列
德发哆啦的博客
05-19 465
当我们用哈希函数的时候，其中一个就是取这个表的长度len,按照哈希函数：Hash(key) = key% len,将这个位置映射到表中通过上面的除留余数法，会有的问题，可以通过来解决也叫，通过线性探测，依次找后面的位置存储。
P6【知识点】【数据结构】【树tree】C++版
qq_50891451的博客
05-22 159
普通二叉树：每个结点最多两个孩子满二叉树：除了叶子结点，每个节点都有两个孩子，且叶子节点在同一层上完全二叉树：从树的根节点，从上到下，从左到右依次填满节点形成的二叉树。
数据结构-单链表
2202_75509654的博客
05-19 341
它由一系列节点组成，每个节点都包含数据域和指向下一节点的指针，链表的节点不需要在内存中连续存放，他们通过指针相互链接，形成一个线性序列。 优点：动态大小、插入删除效率高、内存利用率高、内存利用率高。 缺点：不支持随机访问、额外的指针空间开销 创建、插入、删除、查找、遍历、销毁、合并、删除重复、打印链表等 typedef int datatype; typedef struct node datatype da
数据结构(ArrayList使用)：洗牌算法和杨辉三角
li_wj6的博客
05-19 208
ArrayList的使用练习
C++的数据结构(十四）：图的广度优先遍历（BFS）
全栈工程师Linda的博客
05-21 493
C++的数据结构(十四）：图的广度优先遍历（BFS）
数据结构--栈和队列
最新发布
zy1215058242的博客
05-22 903
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据的插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵守后进先出LIFO（Last In First Out）的原则。压栈：栈的插入操作被称为进栈/压栈/入栈，入数据的地方为栈顶、出栈：栈的删除操作叫做出栈。出数据也在栈顶。出栈、入栈的过程我们可以想象为我们往羽毛球筒里放羽毛球和拿羽毛球，都是只能在一个口进出，是不是可以很形象的想象出来。下面我们来看一看栈是如何实现的。
【数据结构】跳表
m0_70088010的博客
05-19 624
跳表
数据结构双向循环链表
09-27
双向循环链表是一种链表结构，它的每个节点除了有指向下一个节点的指针外，还有指向前一个节点的指针。而且链表的首尾节点相互连接，形成一个环形结构。 相比于单向链表，双向循环链表的优点在于可以方便地进行双向遍历，可以从头到尾或从尾到头遍历链表。同时，双向循环链表也有助于在链表中进行插入和删除操作，因为可以通过前后节点的指针将节点连接起来或断开。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

1e-12

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

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

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

打赏作者

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

抵扣说明：

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

余额充值