数据结构-双向链表

---

🦆 个人主页：深邃-

❄️专栏传送门：《C语言》《数据结构》

🌟Gitee仓库：《C语言》《数据结构》

---

目录

• 链表的分类
• 概念与结构
• • 概念
  • 结构
• 实现双向链表
• • 双向链表申请新节点
  • 初始化链表
  • 销毁链表
  • 尾插
  • 头插
  • 打印链表
  • 链表判空
  • 尾删
  • 头删
  • 查找元素
  • 在pos位置之后插入数据
  • 删除pos位置的节点
• 顺序表与链表的分析

链表的分类

以下两张链表的分类

概念与结构

概念

++注意++ ：这里的"带头"跟前面我们说的"头结点"是两个概念，实际前面的在单链表阶段称呼不严谨，但是为了同学们更好的理解就直接称为单链表的头结点。
带头链表里的头结点，实际为"哨兵位"，哨兵位结点不存储任何有效元素，只是站在这里"放哨的

结构

• 头文件
  定义双向链表结构

//定义双向链表结构
typedef int LTDataType;
typedef struct ListNode {
	LTDataType data;
	struct ListNode* next; //指向下一个节点的指针
	struct ListNode* prev; //指向前一个节点的指针
}LTNode;

接下来实现的函数声明

//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit();

//销毁---为了保持接口一致性
//void LTDesTroy(LTNode** pphead);
void LTDesTroy(LTNode* phead);


//在双向链表中，增删改查都不会改变哨兵位节点
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);

bool LTEmpty(LTNode* phead);
void LTPrint(LTNode* phead);


LTNode* LTFind(LTNode* phead, LTDataType x);
//在pos位置之后插⼊数据----在pos位置之前插入数据自行实现
void LTInsert(LTNode* pos, LTDataType x);

//删除pos位置的节点
void LTErase(LTNode* pos);

实现双向链表

• 源文件

双向链表申请新节点

LTNode * LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;

	return newnode;
}

初始化链表

传二级针织，修改外部phead

void LTInit(LTNode** pphead) //传二级针织，修改外部phead
{
	*pphead = LTBuyNode(-1);
}

优化：不需要传任何值，直接返回初始化的节点 不需要传任何值，直接返回初始化的节点 不需要传任何值，直接返回初始化的节点

//初始化
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

销毁链表

void LTDesTroy(LTNode** pphead)
{
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁头结点
	free(*pphead);
	*pphead = NULL;
}

为了保证接口一致性，我们给出优化
但是注意：传一级指针，返回新的头指针，切记用头指针接收，否则成为野指针

//销毁
LTNode* LTDesTroy(LTNode* phead)
{
	assert(phead != NULL);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁头结点
	free(phead);
	return NULL;
}

尾插

注意顺序，先改头节点的前驱指针的后继节点，再改头节点的前驱指针（否则找尾节点很费劲）

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//phead phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}

头插

注意顺序，同上

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = LTBuyNode(x);
	//phead newnode phead->next
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}

打印链表

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

链表判空

链表成环即为空

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

尾删

//尾删
void LTPopBack(LTNode* phead)
{
	assert(!LTEmpty(phead));

	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;

	free(del);
	del = NULL;
}

头删

//头删
void LTPopFront(LTNode* phead)
{
	assert(!LTEmpty(phead));

	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

查找元素

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//未找到
	return NULL;
}

在pos位置之后插入数据

注意顺序，同上

//在pos位置之后插⼊数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);
	//pos newnode pos->next
	newnode->prev = pos;
	newnode->next = pos->next;

	pos->next->prev = newnode;
	pos->next = newnode;
}

删除pos位置的节点

//删除pos位置的节点
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev pos pos->next
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

顺序表与链表的分析

通过表格理解 \color{blue}{通过表格理解} 通过表格理解

不同点	顺序表	链表（单链表）
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持O(1)	不支持：O(N)
任意位置插入或者删除元素	可能需要搬移元素，效率低O(N)	只需修改指针指向
插入	动态顺序表，空间不够时需要扩容和空间浪费	没有容量的概念，按需申请释放，不存在空间浪费
应用场景	元素高效存储+频繁访问	任意位置高效插入和删除

---