初识双向链表

链表的分类：

链表一共有8种（2 * 2 * 2）链表结构
1. 带头/不带头链表
带头：指的是链表中有哨兵位节点，该哨兵位节点也叫头节点

在前面的链表的实现中，我们口头上说的头节点其实是第一个有效的节点，这不是正确的称呼
为了好理解我们才这样称呼，实际在链表中指的是哨兵位！

2. 单向/双向
单向：指的是只能从一个地方遍历链表
双向：可以从两个方向遍历链表

3. 循环或不循环
循环：指的是链表尾节点的next的指针指向的为NULL；
不循环：指的是链表尾节点的next指针指向的是第一个节点；成了一个环

判断循环还是不循环：尾节点的next指针指向的是否为NULL

我们前面的实现的链表是 不带头单向不循环链表（简称：单链表）；只有后置指针（next）

前面代码中的 SList 的S 表示 single 单的
带头双向循环链表（简称：双向链表）；它既有前置指针（prve），也有后置指针（next）

双向链表示意图：

我们最常用的就是以上的两种，当我们将以上的实现后，其余的也可以自行实现

双向链表结构定义

链表是节点组成的，双向链表的节点是由 数据 + 指向下一个节点的指针 + 指向前一个节点的指针 组成的；

//双向链表的结构初步实现：
struct ListNode
{
	int data;
	struct ListNode* next;
	struct ListNode* prve;
}

双向链表的初始化

单链表和双向链表为空时的情况不一样，单链表为空时，为NULL
在双向链表中，phead == NULL 表示：它不是双向链表
双向链表为空时，链表中有一个哨兵位在，我们初始化时需要创建一个哨兵位
，由于双向链表为循环链表：在初始化时需要达到自循环

List.h

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
//双向链表定义：
typedef int LDatatype;
typedef struct ListNode
{
	LDatatype data;
	struct ListNode* next;
	struct ListNode* prve;
}LTNode;

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

List.c

LTNode* LTBuyNode(LDatatype x)//易错点：函数要有返回值类型； 传参时只有值x
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode*));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);//或return 1; 
	}

	node->data = x;
	node->next = node->prve = node; //双向链表为循环链表：在初始化时需要达到自循环
}

//再来一遍：
void LTInit(LTNode** pphead)
{
	*pphead = LTBuyNode(-1);
}

Test.c

#include"List.h"
void LTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);
}

int main()
{
	LTest01();
	return 0;
}

除销毁以外，传一级还是二级指针问题？
规定：哨兵位节点不能被删除，该节点的地址也不能被删除
建议：传一级即可，二级也可以（但需要做到不能修改哨兵位）

对双向链表进行插入时：需要先将newnode的next和prve的指向改变，再改变原链表中的指向。这样做的好处是先改变newnode，它不会影响原链表

头插

头插是在头节点之后插入（要是再头节点之前插入相当于尾插）
示意图：

核心代码：

void LTPushFrant(LTNode* phead, LDatatype x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead->next;
	newnode->prve = phead;

	////解法1：
	//phead->next->prve = newnode;
	//phead->next = newnode;

	//解法2：
	phead->next = newnode;
	newnode->next->prve = newnode;

}

尾插

为空时：在哨兵位的后面尾插
不为空：在最后一个有效的节点后面进行尾插

核心代码：

void LTPushBack(LTNode* phead, LDatatype x)
{
	assert(phead);//头节点必须要有，满足双向链表的要求后才可以插入

	LTNode* newnode = LTBuyNode(x);

	//开始尾插
	newnode->next = phead;
	newnode->prve = phead->prve;

	////解法1：
	//phead->prve->next = newnode;
	//phead->prve = newnode;

	//解法2：
	phead->prve = newnode;
	newnode->prve->next = newnode;
}

链表打印：

打印不止一个，需要用到循环，由于链表为循环链表，也不打印head，所以循环的结束条件是 当pcur != head进入循环打印（pcur 为指向第一个有效节点的指针）

核心代码：

void LPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;

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

在进行删除操作时，要保证双向链表是有效的，并且保证双向链表不为空
删除时需要注意到：先将要删除的节点创建指针变量del进行保存，然后进行删除操作！

尾删

核心代码：

void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);//删除必须是有效的双向链表 和 双向链表不为空（不能只有一个哨兵位）

	//找到尾删后会有影响的节点：phead phead->prve phead->prve->prve
	//phead->prve->prve->next = phead; 
	//phead->prve = phead->prve->prve;
	//这样做会导致到最后找不到要删除的节点了，因此要创建指针变量

	LTNode* del = phead->prve;

	del->prve->next = phead; 
	phead->prve = del->prve;
	
	free(del);
	del = NULL;
}

头删

核心代码:

void LTPopFrant(LTNode* phead)
{
	assert(phead && phead->next != phead);

	LTNode* del = phead->next;

	phead->next = del->next;
	del->next->prve = phead;

	free(del);
	del = NULL;
}

查找

核心代码：

LTNode* Find(LTNode* phead, LDatatype x)
{
	LTNode* pcur = phead->next;//这里pcur指向的是phead->next 也就是有效的节点
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

在任意位置之后插入数据

在任意位置之前插入数据和这里是一样的，下面也会写出来的

核心代码：

void LTInsert(LTNode* pos, LDatatype x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);

	newnode->prve = pos;
	newnode->next = pos->next;

	////解法1：
	//pos->next->prve = newnode;
	//pos->next = newnode;
	//解法2：
	pos->next = newnode;
	newnode->prve = newnode;
}

LTInsert 包含了头插，但是头插不包含LTInsert

删除pos位置的节点

核心代码：

void LTErase(LTNode* pos)//这里为什么不传二级指针？  为了保持接口的一致性(也就是理论上是对的，但是会增加客户对在这里代码的理解，所以不传)
//传一级不会影响实参，所以我们调用完成后要手动释放掉实参
{
	//pos理论上不能为phead，但是这里没有参数phead，无法使用断言pos !=  phead进行校验
	assert(pos);
	
	//pos->prve  pos  pos->next
	pos->next->prve = pos->prve;
	pos->prve->next = pos->next;
	
	free(pos);
	pos = NULL;
}

前面的初始化也可以为了保持接口的一致性，将哨兵位以返回值的形式初始化，注意这里的返回值类型是LTNode* ，而不是void
核心代码：

//方法2初始化定义：这里没有参数，我们需要自己定义一个哨兵位并作为返回值进行接收
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

上面的方法都是动态申请的，使用完成后需要进行销毁以下是销毁的的操作

销毁

核心代码：

void LTDestry(LTNode* phead)
{
	assert(phead);//必须是有效的双向链表的节点
	LTNode* pcur = phead->next;//这里的pcur一定要指向第一个有效的节点才可以进行销毁
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//这里相当于只剩下哨兵位了 -- 最后要将哨兵位释放
	free(phead);
	phead = NULL;

}

LTErase和LTDestroy参数理论上要传二级,因为我们需要让形参的改变影响到实参，但是为了保持接口一致性才传的一级~
传一级存在的问题是,当形参phead置为NULL后,实参plist不会被修改为NULL,因此解决办法是：调用完方法后手动将实参置为NULL~

plist (保存的地址空间被释放掉了)（这里是指plist指向的空间形参已经被释放了，但没有置空，需要手动置空） 若后续不再使用plist就不会出现问题但是若还需要继续使用plist指针就会出现问题~