双向链表专题

引例

单链表是不带头单向不循环的链表，而双向链表的全称是带头双向循环链表，即尾节点的next指针指向头节点。

双向链表的结构

双向链表为空时，链表中只剩一个头节点，这个头节点我们称作哨兵节点，这个哨兵节点我们一般不会改变，所以后面函数传地址大部分只传一级指针。

下面就是我们实现双向链表所需要的函数

目录

//初始化
void LTInit(LTNode** pphead);//第一种初始化
//创建节点
LTNode* LTBuyNode(LTDataType x);
//打印双向链表
void LTPrint(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead,LTDataType x);//插入之前，链表中必须含有一个头节点,且无法被修改
//头插
void LTPushFront(LTNode* phead,LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);
//在pos后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);
//查找
LTNode* LTFind(LTNode* phead, LTDataType x);
//销毁链表
void LTDestroy(LTNode* phead);

创建结构体

typedef int LTDataType;
typedef struct ListNode 
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

1.创建节点

需要注意的是，在双向链表中，我们要创建一个可以前后互相指向的链表，所以我们需要在结构体中额外加入prev指针，且不能将头节点的prev和next指针指向NULL，否则后面对于头节点的指针指向改变难以执行，以下是创建节点的函数：

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		return;
	}
	node->data = x;
	node->next = node->prev = node;//让指针指向自己
	return node;
}

2.链表的初始化

在链表的初始化中，我们需要通过初始化中的形参来改变实参，所以这里我们传二级指针，将创建节点的值给到实参即可，代码如下：

void LTInit(LTNode** pphead)
{
	//先创建一个哨兵位
	*pphead = LTBuyNode(-1);
}

//初始化方法
LTNode* plist = NULL;
LTInit(&plist);

而我们的目录中后面函数大多都为一级指针，这里我们为了形式相同，也可以通过一级指针传值给我们的实参，代码如下：

LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

//初始化方法
LTNode* plist = LTInit();//将return的值给到plist

3.打印链表

这里我们将pcur定义为哨兵节点下一个节点，再通过遍历俩链表来打印链表，代码如下：

void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;//pcur向后移动
	}
	printf("\n");
}
//打印函数的使用
LTPrint(plist);

4.尾插函数

我们不会改变哨兵位，所以传一级指针，为了防止指针指向位置消失，我们先改变newnode的指向，在这里，我们先将newnode->prev指向d3(phead->prev),同时newnode->next指向phead，再将d3->next指向phead的指针改变为指向newnode的指针，同时将phead->prev指针由指向d3改变为指向newnode，如下示意图：

  代码如下： 

void LTPushBack(LTNode* phead, LTDataType x)//一级即可，不改变哨兵位
{
	assert(phead);//头节点为空，则改结构体不为双向链表
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead->prev;//先改phead
	newnode->next = phead;

	phead->prev->next = newnode;//尾节点的修改，且这两行不能修改位置
	phead->prev = newnode;//头节点的修改
}

5.头插函数

头插函数需要将newnode插到哨兵位后，就像尾插操作，我们先调整newnode的指针指向：newnode->next指向d1(phead->next),同时newnode->prev指向phead，如图所示：

接下来，再将d1(phead->next)->prev指针指向newnode，同时将phead->next指向newnode,如图所示：

代码如下：

void LTPushFront(LTNode* phead, LTDataType x)//注意头插是往哨兵位后插
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;//改变d1
	phead->next = newnode;//改变头节点
}

6.尾删函数

首先要进行判断，如果链表为空(phead->next为空)，或者哨兵节点都不存在，那就直接断言。如果我们要删除尾节点，那么d2和哨兵节点就会受到影响，

在这里，我们改变d2(phead->prev->prev)->next指针由指向d3到指向phead,同时将phead->prev指向由d3改变为d2。式子是这样：

但在这里，我们想要销毁d3时,却发现d3的地址已经找不到了，所以我们要提前将d3的地址存储起来，这里我们不妨将其设为del，这样，我们的代码也可以简化一点，代码如下：

void LTPopBack(LTNode* phead)
{
	//只有一个哨兵位代表为空
	assert(phead && phead->next != phead);
	LTNode* del = phead->prev;

	del->prev->next = phead;
	phead->prev = del->prev;
	//删除del节点
	free(del);
	del == NULL;
}

7.头删函数

头删函数，要删除的指针是哨兵位后一个节点d1(phead->next),同样地，我们将d1用del存储起来，再将d2(del->next)->prev指向改为phead,phead->next指向改为d2,最后再对del进行释放即可。代码如下：

void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);//链表不为空
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

8.查找函数

查找函数需要遍历链表，仍然是从phead->next循环开始，到phead结束循环。找到就返回地址，没找到就返回空，代码如下：

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

9.在pos后插入数据

在这里的pos需要接收到一个pos指针，这里就需要用到上一个find找到的指针地址了，这里我们假设pos就是d2(phead->prev->prev)

仍然是先改变newnode出去的指针，newnode->next指向d3(pos->next),同时newnode->prev指向pos，再将d2(pos)->next->prev指向newnode,再将pos->next指向newnode。

注意：1.此处这两句不可以交换位置，否则pos->next如果改变了指向，就会导致pos->next->prev改变指向！

2.此处的pos是一级指针，可能会被改变，所以我们要主动销毁掉find值：find = NULL;

代码如下：

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);

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

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

10.删除节点

这里传入的pos指针仍然是find函数找到的指针。我们可以通过pos来找到这三个节点d3(pos->next)->prev指向d1(pos->prev)，d1->next指向d3。

注意：此处的pos是一级指针，可能会被改变，所以我们要主动销毁掉find值：find = NULL;

代码如下：

void LTErase(LTNode* pos)
{
	assert(pos);//pos不能为哨兵位
	//通过pos找这三个节点
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

11.销毁链表函数

销毁链表，仍然需要遍历链表，值得注意的是，我们每次进入循环后销毁数据时，需要防止后续找不到这个销毁的地址，所以我们仍也要创建一个变量来储存这个地址。退出循环后，pcur指向哨兵节点phead,但phead并没有被销毁，所以我们要主动销毁它，代码如下：

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;	
}

像这样，一个双向链表的完成函数就完成了！

总结

相比于单链表来说，双向链表要遍历的地方少一些了，链表的节点的前一个节点也更好找，而不像单链表那样每找一个prev都要遍历链表，这也大大减少了我们的代码量；同时也使我们更容易地循环链表，为节省空间起到了作用，是我们用的更多的一个链表结构。