数据结构·双向链表

1. 双向链表的结构

        我们之前提到过，双向链表的全称是：带头双向循环链表。带头就是相当于一个“哨兵位”，用来标记链表的开始，它存储的数据是无效的，但是它将存储有效的前驱节点和后继节点的地址，带头链表的好处我们在上节例题中体会到了。

        下面展示双向链表的结构：

        每个节点中存放3个成员，分别是上一节点的地址，该节点保存的数据，和下一节点的地址。然后把它们带上头再循环串起来就完成了。

2. 双向链表的实现

        老规矩3个文件先创建好，然后再创建链表节点的结构体

                

        下面我们开始实现链表的各种功能

2.1 初始化、销毁和打印

2.1.1 初始化

        双向链表是带头的，或者说有哨兵位的，所以插入数据之前链表中必须先初始化一个哨兵位

        

2.1.2 销毁

        销毁很简单，边遍历链表边销毁就好了，注意销毁之前要把下一个节点的地址保存下来，还有就是不要忘记把哨兵位也销毁掉

        因为最后一句话涉及到修改哨兵位成空指针，所以参数要传二级指针

        

2.1.3 打印

        打印的话就从头节点的下一个节点开始扫描，直到看到头节点结束

        ​​​​​​​

2.2 链表的插入

        插入前先申请一个新节点

2.2.1 尾插

        双向链表的插入要比单链表简单很多，对于尾插来说，单链表我们还要遍历链表以找到尾节点，但是双向链表的尾节点就是头节点的上一个节点，所以不需要遍历了。

        同时添加新节点的时候我们不需要观察目前链表是否为空，因为链表初始化的时候就已经加好头节点了，所以链表一定不为空。

        还有就是因为头节点是固定存在的，所以我们在插入新节点的时候不可能涉及到改变头节点的地址，所以在传参的时候我们只需要传链表的头节点的一级指针就够了，这一点在头插的时候表现的更明显。

        但是在插入的时候要注意节点链接的顺序，先把新节点接进去，在拆开旧节点的链子，重新链接。

        ​​​​​​​        ​​​​​​​

2.2.2 头插

        头插的时候因为头节点是固定的，所以再头插的时候都统一插在头节点的后面，也就不用考虑改变头节点了，只需要断言一下有没有头节点就行

        

        

2.3 链表的删除

2.3.1 尾删

        删除的话我们传一个参数就可以了，然后要注意的是多断言了一个链表不为空，还有就是自己要想好删除的时候链子链接的顺序。

        

2.3.2 头删

        双向链表的头删跟尾删几乎没有区别，注意的点也一样

        

2.4 查找

        

2.5 在任意位置插入和删除

2.5.1 在pos位置之后插入数据

        这也没啥好说的，注意先把新节点接进去，在接别的链子，防止有点指针给整丢了

        

2.5.2 删除pos位置数据

        这个更简单，记得连好之后把pos free掉就好了

        

3. 结语

        最后，我们对比一下双向链表的逻辑看起来似乎比单链表难一点，但是实际写代码的时候反而比单链表方便许多，尤其是有头节点或者说哨兵位的加入，我们不需要考虑那么多判断，头节点是否要移动的情况。

        再说回链表和顺序表的区别，顺序表的缺点是如果要删除某个数据，就要移动一整个顺序表中的数据，效率很低。但是顺序表和链表还是有相互的长处，顺序表适用于那种元素高效存储和频繁访问的情况，而链表适用于任意位置插入和删除频繁的情况，总之，各有所长，大家在实际应用中灵活运用吧。

4. 完整代码

        本节的完整代码双手呈上：

        List.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//定义节点结构
typedef int DataType;
typedef struct ListNode 
{
	int data;
	struct ListNode* prev;
	struct ListNode* next;

}LTNode;

//双向链表是带头的，或者说有哨兵位的
//所以插入数据之前链表中必须先初始化一个哨兵位
//初始化和销毁
void LTInit(LTNode** pphead);
void LTDestory(LTNode** pphead);

//双向链表的打印
void LTPrint(LTNode* phead);

//哨兵位不需要改变，所以不用传二级指针了
//尾插
void LTPushBack(LTNode* phead, DataType x);
//头插
void LTPushFront(LTNode* phead, DataType x);


//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);


//查找
LTNode* LTFind(LTNode* phead, DataType x);

//在任意位置插入和删除
//在pos位置之后插入数据
void LTInsert(LTNode* pos, DataType x);
//删除pos位置数据
void LTEraze(LTNode* pos);

        List.h

#include"List.h"

//初始化和销毁
//初始化
void LTInit(LTNode** pphead)
{
	*pphead = (LTNode*)malloc(sizeof(LTNode));
	if (*pphead == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	(*pphead)->data = -1;
	//因为目前只有一个节点
	//所以哨兵位的前面和后面一个节点都是他自己
	(*pphead)->prev = *pphead;
	(*pphead)->next = *pphead;
}

//销毁
void LTDestory(LTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);
	
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//链表中只有哨兵位了
	free(*pphead);
	*pphead = NULL;
}

 
//双向链表的打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}





//申请新节点
LTNode* LTBuyNode(DataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL;
	return newnode;
}


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

	//再处理之前的连线
	phead->prev->next = newnode;
	phead->prev = newnode;
}

//头插
void LTPushFront(LTNode* phead, DataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//先链接新节点
	newnode->prev = phead;
	newnode->next = phead->next;
	//再链接其他
	phead->next->prev = newnode;
	phead->next = newnode;
}



//尾删
void LTPopBack(LTNode* phead)
{
	//不能没有头节点，说明链表还没有初始化
	assert(phead);
	//不能只有头节点，说明链表为空
	assert(phead->next != phead);

	//先让头节点的链子栓到倒数第二个节点上
	phead->prev = phead->prev->prev;
	//释放倒数第一个节点
	free(phead->prev->next);
	//倒数第二个节点的下一个节点是头节点
	phead->prev->next = phead;
}

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	phead->next = phead->next->next;
	free(phead->next->prev);
	phead->next->prev = phead;
}




//查找
LTNode* LTFind(LTNode* phead, DataType x)
{
	assert(phead);
	assert(phead->next != phead);

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




//在任意位置插入和删除
//在pos位置之后插入数据
void LTInsert(LTNode* pos, DataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	newnode->next->prev = newnode;
	pos->next = newnode;
}


//删除pos位置数据
void LTEraze(LTNode* pos)
{
	assert(pos);

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}