C语言.数据结构.双向链表

1.双向链表的结构

1.1链表的简单介绍

• 注意：这里的“带头”跟前面所说的“头节点”是两个概念，实际前面的在单链表阶段称呼不严谨，但是为了方便理解，就直接称为单链表的头节点
• 带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何的有效元素，只能站在这里“放哨的”
• “哨兵位”存在的意义：
  遍历循环链表避免死循环。

1.2图文分析

2.实现双向链表

2.1链表的初始化

2.1.1初始化

//链表的初始化
void LTInit(LTNode** pphead)
{//哨兵位节点不存储任何的有效元素，只能站在这里“放哨的”，传递一个什么样的值都可以
	*pphead = LTBuyNode(-1);
}

2.1.2节点的申请

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	//走到这 证明申请成功
	node->data = x;
	//给双向链表一个哨兵位，使得自己指向自己
	node->next = node->prev = node;
}

2.2链表的打印

2.2.1代码实现

//链表的打印
void LTPrint(LTNode* phead)
{
	//哨兵位不用打印，有效节点为哨兵位的下一个节点
	LTNode* pcur = phead->next;
	//本质还是遍历链表
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		//pcur指针往下走
		pcur = pcur->next;
	}
	printf("\n");
}

2.2.2图文分析

2.3链表的尾插

2.3.1代码实现

//链表的尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//让newnode插在phead->prev(头结点的前一个节点)和phead之间
	newnode->prev = phead->prev;
	newnode->next = phead;
	
	phead->prev->next = newnode;
	phead->prev = newnode;//两者不能交换位置
}

2.3.2图文分析

2.4链表的头插

2.4.1代码实现

//链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	//头插：插在有效节点的前面，也就是头节点的后面
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//把newnode节点插在phead和phead->next之间
	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;
	phead->next = newnode;//这两行代码不能完全交换
}

2.4.2图文分析

2.5链表的尾删

2.5.1代码实现

//链表的尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效，且链表不能为空(只有一个哨兵位,自己指向自己)
	assert(phead && phead->next != phead);
	//要删除的节点
	LTNode* del = phead->prev;
	//要改变尾节点的前一个节点的指向 应该指向的是头节点（原本指向del的）
	del->prev->next = phead;
	//头结点的前一个节点就应该指向del->prev
	phead->prev = del->prev;

	//把尾节点内存释放掉,删除del节点
	free(del);
	del = NULL;
}

2.5.2图文分析

2.6链表的头删

2.6.1代码实现

//链表的头删
void LTPopFront(LTNode* phead)
{
	//链表必须有效，且链表不能为空(只有一个哨兵位,自己指向自己)
	assert(phead && phead->next != phead);
	//要删除的节点 -> 链表中第一个有效节点
	LTNode* del = phead->next;

	del->next->prev = phead;
	phead->next = del->next;//这两个可以交换
	//删除del节点
	free(del);
	del = NULL;
}

2.6.2图文分析

2.7在pos位置之后插入数据

2.7.1代码实现

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	//也就是说，在pos与pos->next之间插入一个x节点
	newnode->next = pos->next;
	newnode->prev = pos;
	//既然是双向链表，肯定是有两个方向
	pos->next->prev = newnode;
	pos->next = newnode;
}

2.7.2图文分析

2.8删除pos位置节点

2.8.1代码实现

//删除pos位置节点
void LTErase(LTNode* pos)
{
	assert(pos);
	//就是把pos->prev和pos->next之间删除pos节点
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	//删除pos位置节点
	free(pos);
	pos = NULL;
}

2.8.2图文分析

2.9查找节点

2.9.1代码实现

//查找节点
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	//就是自己传递的形参x 与链表中的有效数据进行对比，遍历链表
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//走到这，证明没有找到对应的数据，返回一个空指针
	return NULL;
}

2.10链表的销毁

2.10.1代码实现

//链表的销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		//先把要删除的下一个节点的位置保存下来，否则就找不到下一个节点的位置
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//此时pcur指向了phead,而phead并未销毁，
	free(phead);
	phead = NULL;
}

2.10.2图文分析

3.顺序表和双向链表的分析

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