• 【初阶数据结构】带头双向循环链表（C语言实现）

    文章目录

    链表介绍

    前篇已经说到，链表的结构可以分为八种：带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。

    在这八种结构中，我们只选取两种来解析：无头单向非循环链表(单链表) 和 带头双向循环链表。
    在这里插入图片描述
    无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
    带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了

    在【初阶数据结构】单链表(C语言实现+动图演示)中，我们已经对单链表进行了解析，本篇我们将对带头双向循环链表进行解析

    链表的实现

    双向链表的结构体的定义

    与单链表相比，双向链表的结构体中多了一个前驱指针，用于指向前面一个结点，从而实现双向。

    typedef int LTDataType;//存储的数据类型

typedef struct ListNode
{
	struct ListNode* next;//后继指针
	struct ListNode* prev;//前驱指针
	LTDataType data;//存储数据
}LTNode;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    双向链表的接口实现

    //初始化
LTNode* ListInit();
//打印
void ListPrint(LTNode* phead);

//判断链表是否为空
bool ListEmpty(LTNode* phead);

//尾插
void ListPushBack(LTNode* phead, LTDataType x);
//尾删
void ListPopBack(LTNode* phead);

//头插
void ListPushFront(LTNode* phead, LTDataType x);
//头删
void ListPopFront(LTNode* phead);

//在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x);
//删除pos位置
void ListErase(LTNode* pos);

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    双向链表的初始化

    在单链表中，我们无需对单链表进行初始化，但对于双向链表来说，我们是需要对其进行初始化的。
    在初始化过程中，我们需要申请一个哨兵位头结点，哨兵位头结点的前驱后继指针都指向自己，使链表一开始就满足带头循环。
    在这里插入图片描述

    注：当我们申请了一个哨兵位头结点后，我们在进行传参时，就无需传二级指针了，因为不会修改头指针，这就是带头的好处。这在上一篇总结中说过。

    代码实现：

    //初始化
LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));//创建一个哨兵位的头节点
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;

	return guard;//返回哨兵位头结点
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    双向链表的打印

    打印双向链表时，我们需要遍历一遍双向链表，不过遍历双向链表需要注意循环的条件，从第一个有效结点phead->next开始，当其等于哨兵位头节点时结束。

    请添加图片描述

    代码实现：

    //打印
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//从头节点的下一个结点开始打印
	while (cur != phead)//当cur指针指向头节点时，说明链表打印结束
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    双向链表的判空

    在我们进行删除操作时，我们需要进行判断双向链表是否为空链表，为空则不能进行删除。

    代码实现：

    //判断链表是否为空
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    双向链表的尾插尾删

    尾插

    尾插，首先要创建一个新的结点，然后找到链表的尾结点phead->prev，因为头节点的前驱指针是直接指向最后一个结点，所以我们不需要遍历链表找尾。
    在这里插入图片描述

    代码实现：

    //尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;//记录尾结点
	//建立尾结点与新节点之间的双向关系
	tail->next = newnode;
	newnode->prev = tail;
	//建立新结点与头结点之间的双向关系
	newnode->next = phead;
	phead->prev = newnode;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    尾删

    先找到尾结点tail和其前驱结点prev，再通过修改链接关系进行删除。头节点的prev指向前驱结点prev，前驱结点prev的next指向头结点。在释放掉尾结点tail
    在这里插入图片描述

    代码实现：

    //尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//判断链表是否为空

	LTNode* tail = phead->prev;//记录尾结点
	LTNode* prev = tail->prev;//记录尾结点前一个结点
	
	//建立头结点与prev结点之间的双向关系
	phead->prev = prev;
	prev->next = phead;
	free(tail);//释放tail结点
	tail = NULL;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    双向链表的头插头删

    头插

    头插，首先申请一个新结点，将新结点插入头结点和其下一个结点的中间即可。
    在这里插入图片描述

    代码实现：

    //头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);//申请一个新结点，数据域赋值为x
	LTNode* cur = phead->next;//记录头结点下一个结点
	
	//建立新结点与头结点之间的双向关系
	phead->next = newnode;
	newnode->prev = phead;
	
	//建立新结点与cur结点之间的双向关系
	newnode->next = cur;
	cur->prev = newnode;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    头删

    头删，即释放掉头结点的下一个结点，使头结点指向其删除结点的下一个结点。
    在这里插入图片描述
    实现代码时需要注意操作多个结点时，尽量多定义变量以避免混淆中各逻辑关系，同时使得代码逻辑清晰，简洁明了。

    代码实现：

    //头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	LTNode* first = phead->next;//记录头结点的后一个结点
	LTNode* second = first->next;//记录first结点的下一个结点

	//建立头结点与second结点之间的双向关系
	phead->next = second;
	second->prev = phead;
	free(first);//释放掉first结点
	first = NULL;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    双向链表的查找

    查找链表，给定一个值，遍历链表，若在链表中找到与该值相同的结点，返回该结点的地址，否则返回NULL。

    遍历方法以及循环结束条件与打印链表一致

    代码实现：

    //查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;//从头结点的后一个结点开始查找
	while (cur != phead)//当cur指向头结点时，说明链表已遍历完毕
	{
		if (cur->data == x)
			return cur;//找到返回其地址
		cur = cur->next;
	}
	return NULL;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    双向链表的指定位置插入删除

    在指定位置前插入结点

    在指定位置前插入新结点，需要记录指定位置的前一个结点，然后在进行插入。

    代码实现：

    //在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;//记录pos位置的前一个结点
	
	//建立prev与新结点的双向关系
	prev->next = newnode;
	newnode->prev = prev;
	//建立新结点与pos的双向关系
	newnode->next = pos;
	pos->prev = newnode;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    删除指定位置结点

    删除指定位置的结点，我们只需将该位置的前一个结点和该位置的后一个结点建立双向关系，然后在释放掉该位置的结点即可。

    代码实现：

    //删除pos位置
void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;//记录pos位置的前一个结点
	LTNode* next = pos->next;//记录pos位置的下一个结点

	//建立前后两节点之间的双向关系
	prev->next = next;
	next->prev = prev;
	free(pos);//释放掉pos位置的结点
	pos = NULL;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    因为双向链表的循环特性，当在头结点之前插入就相当于尾插。
    所以头尾操作都可以复用其在指定位置的删除操作。

    我将复用操作在下列完整代码中使用。

    双向链表的销毁

    销毁链表，从头结点的下一个结点开始向后遍历，依次释放，直到遍历到头结点时结束，然后将头结点也释放掉。

    代码实现：

    //销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//记录头结点的下一个结点
	while (cur != phead)
	{
		LTNode* next = cur->next;//记录cur的后一个结点位置，便于遍历链表
		free(cur);
		cur = next;
	}
	free(phead);//释放头结点
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    完整代码

    //初始化
LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));//创建一个哨兵位的头节点
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;

	return guard;//返回哨兵位头结点
}
//打印
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//从头节点的下一个结点开始打印
	while (cur != phead)//当cur指针指向头节点时，说明链表打印结束
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//判断链表是否为空
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}
//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;//记录尾结点
	//建立尾结点与新节点之间的双向关系
	tail->next = newnode;
	newnode->prev = tail;
	//建立新结点与头结点之间的双向关系
	newnode->next = phead;
	phead->prev = newnode;
}
//尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//判断链表是否为空

	LTNode* tail = phead->prev;//记录尾结点
	LTNode* prev = tail->prev;//记录尾结点前一个结点
	
	//建立头结点与prev结点之间的双向关系
	phead->prev = prev;
	prev->next = phead;
	free(tail);//释放tail结点
	tail = NULL;
}
//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);//申请一个新结点，数据域赋值为x
	LTNode* cur = phead->next;//记录头结点下一个结点
	
	//建立新结点与头结点之间的双向关系
	phead->next = newnode;
	newnode->prev = phead;
	
	//建立新结点与cur结点之间的双向关系
	newnode->next = cur;
	cur->prev = newnode;

}
//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	LTNode* first = phead->next;//记录头结点的后一个结点
	LTNode* second = first->next;//记录first结点的下一个结点

	//建立头结点与second结点之间的双向关系
	phead->next = second;
	second->prev = phead;
	free(first);//释放掉first结点
	first = NULL;
}
//查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;//从头结点的后一个结点开始查找
	while (cur != phead)//当cur指向头结点时，说明链表已遍历完毕
	{
		if (cur->data == x)
			return cur;//找到返回其地址
		cur = cur->next;
	}
	return NULL;

}
//在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;//记录pos位置的前一个结点
	
	//建立prev与新结点的双向关系
	prev->next = newnode;
	newnode->prev = prev;
	//建立新结点与pos的双向关系
	newnode->next = pos;
	pos->prev = newnode;
}
//删除pos位置
void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;//记录pos位置的前一个结点
	LTNode* next = pos->next;//记录pos位置的下一个结点

	//建立前后两节点之间的双向关系
	prev->next = next;
	next->prev = prev;
	free(pos);//释放掉pos位置的结点
	pos = NULL;
}
//销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//记录头结点的下一个结点
	while (cur != phead)
	{
		LTNode* next = cur->next;//记录cur的后一个结点位置，便于遍历链表
		free(cur);
		cur = next;
	}
	free(phead);//释放头结点
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145

    总结

    顺序表和链表的区别

    顺序表

    优点：

    1. 尾插尾删效率很高
    2. 随机访问
    3. 相比链表结构，顺序表cpu高速缓存命中率更高

    缺点：

    1. 头部和中部插入删除效率低。–O(N)
    2. 扩容。-- 性能消耗+空间浪费

    链表

    优点：

    1. 在任意位置插入删除效率很高。–O(1)
    2. 按需申请释放空间。

    缺点：

    1. 不支持随机访问
    2. 链表存储数据同时还需存储前后指针，一定的消耗。
    3. CPU高速缓冲命中率更低
  • 相关阅读:
    2022 年最受瞩目的新特性 CSS @layer 到底是个啥？
    C++交叉编译grpc
    【Rust日报】2023-09-06 Grillon - API 测试框架
    杰理之、产线装配环节【篇】
    Kotlin语法学习(三)_Lambda编程
    Hadoop面试题+详解
    apache mina实现sftp的文件上传与权限修改功能
    (热门)智慧社区助力实现社区数字化转型
    Android OkHttp/Retrofit框架使用Interceptor 抓包/mock数据
    python中math模块
  • 原文地址：https://blog.csdn.net/m0_58124165/article/details/126544970