探索数据结构：双向链表的灵活优势

Betty’s Sweet2024-03-21 20:42

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法

贝蒂的主页：Betty's blog

1. 前言

前面我们学习了单链表，它解决了顺序表中插入删除需要挪动大量数据的缺点。但同时也有仍需改进的地方，比如说：我们有时候需要寻找某个节点的前一个节点，对于单链表而言只能遍历，这样就可能造成大量时间的浪费。为了解决这个问题，我们就要学习今天的主角------带头双向循环链表。

2. 双向链表的功能

  1. 初始化顺序表中的数据。
  2. 对顺序表进行尾插(末尾插入数据)。
  3. 对顺序表进行头插(开头插入数据)。
  4. 对顺序表进行头删(开头删除数据)。
  5. 对顺序表进行尾删(末尾删除数据)。
  6. 对顺序表就像查找数据。
  7. 对顺序表数据进行修改。
  8. 任意位置的删除和插入数据。
  9. 打印顺序表中的数据。
  10. 销毁顺序表。

3. 双向链表的定义

双向链表的定义结构体需要包含三个成员，一个成员存储数值，一个成员存储前一个节点的地址，最后一个成员存储下一个节点的地址。

c 复制代码 
typedef int LTDataType;
typedef struct DoubleList
{
	struct DoubleList* prev;//指向前一个节点
	LTDataType data;
	struct DoubleList* next;//指向下一个节点
}DListNode;

4. 双向链表的功能

4.1 初始化双向链表

在初始化双向链表时，我们需要创建一个头节点，也就是我们常说的哨兵位头节点。

(1) 创建头结点
c 复制代码 
DListNode* DLNodeCreat(LTDataType x)
{
	DListNode* newnode = (DListNode*)malloc(sizeof(DListNode));
	if (newnode == NULL)
	{
		perror("malloc fail:");
		return NULL;
	}
	newnode->prev = NULL;
	newnode->next = NULL;
	newnode->data = x;
	return newnode;
}
(2) 初始化

初始化将头节点的前后指针都指向自己，并将数值至为-1。

c 复制代码 
DListNode* InitDList()
{
	DListNode* phead = DLNodeCreat(-1);
	phead->prev = phead;
	phead->next = phead;
	return phead;
}
(3) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：固定创造一个节点，空间复杂度为O(1)。

4.2 双向链表尾插

因为我们实现的双向链表存在头节点，所以我们不需要像实现单链表一样先判断链表是否为空。

(1) 代码实现
c 复制代码 
void DListPushBack(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* tail = ptr->prev;
	DListNode* newnode = DLNodeCreat(x);
	tail->next = newnode;
	newnode->prev = tail;
	ptr->prev = newnode;
	newnode->next = ptr;
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：固定创造一个节点，空间复杂度为O(1)。

4.3 双向链表头插

因为带头双向循环链表的特性，即使只有头节点进行头插，代码实现也是相同的。

(1) 代码实现
c 复制代码 
void DListPushFront(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* next = ptr->next;
	DListNode* newnode = DLNodeCreat(x);
	ptr->next = newnode;
	newnode->prev =ptr;
	newnode->next = next;
	next->prev = newnode;
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：固定创造一个节点，空间复杂度为O(1)。

4.4 双向链表尾删

有了循环找尾节点也十分容易，双向链表尾删自然并不困难。但是需要防止删除头节点。

(1) 代码实现
c 复制代码 
void DListPopBack(DListNode* ptr)
{
	assert(ptr);
	assert(ptr->next != ptr);//放置删除头节点
	DListNode* tail = ptr->prev;
	DListNode* tailprev = tail->prev;
	free(tail);
	tail == NULL;
	tailprev->next = ptr;
	ptr->prev = tailprev;
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.5 双向链表头删

头删与尾删一样，都需要防止删除头节点。

(1) 代码实现
c 复制代码 
void DListPopFront(DListNode* ptr)
{
	assert(ptr);
	assert(ptr->next != ptr);
	DListNode* phead = ptr->next;
	DListNode* pheadnext = phead->next;
	free(phead);
	ptr->next = pheadnext;
	pheadnext->prev = ptr;
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.6 双向链表查找

和单链表一样，我们也可以对双向链表进行查找。如果找到就返回该节点的地址，否则返回NULL。

(1) 代码实现
c 复制代码 
DListNode* DListFind(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
(2) 复杂度分析
  • 时间复杂度：可能需要遍历整个链表，时间复杂度为O(N)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.7 修改双向链表

我们可以结合双向链表的查找，对双向链表进行修改。

(1) 代码实现
c 复制代码 
void DListModify(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	assert(ptr != pos);//防止对头节点操作
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		if (cur == pos)
		{
			cur->data = x;
		}
		cur = cur->next;
	}
}
(2) 复杂度分析
  • 时间复杂度：可能需要遍历整个链表，时间复杂度为O(N)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.8 双向链表指定插入数据

随机插入数据可以分为：向前插入 与向后插入。

(1) 向前插入
c 复制代码 
void DListInsertF(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	DListNode* newnode = DLNodeCreat(x);
	DListNode* prev = pos->prev;
	newnode->prev = prev;
	newnode->next = pos;
	prev->next = newnode;
	pos->prev = newnode;
}
(2) 向后插入
c 复制代码 
void DListInsertB(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	DListNode* newnode = DLNodeCreat(x);
	DListNode* next = pos->next;
	newnode->prev = pos;
	newnode->next = next;
	next->prev = newnode;
	pos->next = newnode;
}
(3) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.9 指定位置删除数据

任意删除也需要放置删除头节点，并且因为其特点只需要一个参数就能完成该操作。

(1) 代码实现
c 复制代码 
void DListErase(DListNode* pos)
{
	assert(pos);
	assert(pos != pos->next);
	pos->prev->next = pos -> next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.10 打印双向链表

打印双向链表只需将循环之前的数据全部打印即可。

(1) 代码实现
c 复制代码 
void DLTPrint(DListNode* ptr)
{
	assert(ptr);
	printf("guard");
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		printf("<==>%d", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

4.11 销毁双向链表

(1) 代码实现
c 复制代码 
void DListDestroy(DListNode* ptr)
{
	assert(ptr);
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		DListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(ptr);
}
(2) 复杂度分析
  • 时间复杂度：没有其他额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5. 完整代码

5.1 DList.h

c 复制代码 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct DoubleList
{
	struct DoubleList* prev;//指向前一个节点
	LTDataType data;
	struct DoubleList* next;//指向下一个节点
}DListNode;
DListNode* InitDList();//初始化
void DListPushBack(DListNode* ptr, LTDataType x);//尾插
void DLTPrint(DListNode* ptr);//打印
void DListPushFront(DListNode* ptr, LTDataType x);//头插
void DListPopBack(DListNode* ptr);//尾删
void DListPopFront(DListNode* ptr);//头删
DListNode*DListFind(DListNode* ptr, LTDataType x);//查找
void DListModify(DListNode* ptr, DListNode* pos);//修改
void DListInsertF(DListNode* ptr, DListNode* pos, LTDataType x);//任意位置之前插入
void DListInsertB(DListNode* ptr, DListNode* pos, LTDataType x);//任意位置之后插入
void DListErase(DListNode* pos);//任意位置删除
void DListDestroy(DListNode* ptr);//销毁双向链表

5.2 DList.c

c 复制代码 
#include"DoubleList.h"
DListNode* DLNodeCreat(LTDataType x)
{
	DListNode* newnode = (DListNode*)malloc(sizeof(DListNode));
	if (newnode == NULL)
	{
		perror("malloc fail:");
		return NULL;
	}
	newnode->prev = NULL;
	newnode->next = NULL;
	newnode->data = x;
	return newnode;
}
DListNode* InitDList()
{
	DListNode* phead = DLNodeCreat(-1);
	phead->prev = phead;
	phead->next = phead;
	return phead;
}
void DListPushBack(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* tail = ptr->prev;
	DListNode* newnode = DLNodeCreat(x);
	tail->next = newnode;
	newnode->prev = tail;
	ptr->prev = newnode;
	newnode->next = ptr;
}
void DListPushFront(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* next = ptr->next;
	DListNode* newnode = DLNodeCreat(x);
	ptr->next = newnode;
	newnode->prev =ptr;
	newnode->next = next;
	next->prev = newnode;
}
void DListPopBack(DListNode* ptr)
{
	assert(ptr);
	assert(ptr->next != ptr);//放置删除头节点
	DListNode* tail = ptr->prev;
	DListNode* tailprev = tail->prev;
	free(tail);
	tail == NULL;
	tailprev->next = ptr;
	ptr->prev = tailprev;
}
void DListPopFront(DListNode* ptr)
{
	assert(ptr);
	assert(ptr->next != ptr);
	DListNode* phead = ptr->next;
	DListNode* pheadnext = phead->next;
	free(phead);
	ptr->next = pheadnext;
	pheadnext->prev = ptr;
}
DListNode* DListFind(DListNode* ptr, LTDataType x)
{
	assert(ptr);
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void DListModify(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	assert(ptr != pos);//防止对头节点操作
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		if (cur == pos)
		{
			cur->data = x;
		}
		cur = cur->next;
	}
}
void DListInsertF(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	DListNode* newnode = DLNodeCreat(x);
	DListNode* prev = pos->prev;
	newnode->prev = prev;
	newnode->next = pos;
	prev->next = newnode;
	pos->prev = newnode;
}
void DListInsertB(DListNode* ptr, DListNode* pos, LTDataType x)
{
	assert(ptr);
	DListNode* newnode = DLNodeCreat(x);
	DListNode* next = pos->next;
	newnode->prev = pos;
	newnode->next = next;
	next->prev = newnode;
	pos->next = newnode;
}
void DListErase(DListNode* pos)
{
	assert(pos);
	assert(pos != pos->next);
	pos->prev->next = pos -> next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}
void DLTPrint(DListNode* ptr)
{
	assert(ptr);
	printf("guard");
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		printf("<==>%d", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void DListDestroy(DListNode* ptr)
{
	assert(ptr);
	DListNode* cur = ptr->next;
	while (cur != ptr)
	{
		DListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(ptr);
}
相关推荐
ChoSeitaku1 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程1 小时前
双向链表专题
数据结构
香菜大丸1 小时前
链表的归并排序
数据结构·算法·链表
jrrz08281 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
@小博的博客1 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
南宫生2 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
懒惰才能让科技进步3 小时前
从零学习大模型（十二）-----基于梯度的重要性剪枝（Gradient-based Pruning）
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
DARLING Zero two♡3 小时前
关于我、重生到500年前凭借C语言改变世界科技vlog.16——万字详解指针概念及技巧
c语言·开发语言·科技
love_and_hope3 小时前
Pytorch学习--神经网络--搭建小实战（手撕CIFAR 10 model structure）和 Sequential 的使用
人工智能·pytorch·python·深度学习·学习
Chef_Chen3 小时前
从0开始学习机器学习--Day14--如何优化神经网络的代价函数
神经网络·学习·机器学习
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解