【数据结构初阶】：带头双向循环链表（用C语言实现，附图详解）

一、带头双向循环链表

前面我们实现了无头单向非循环链表，特性为：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在OJ题中出现很多，所以我们才要模拟实现充分了解它的特性。

而无头单向非循环链表是有缺点的，那就是尾插和尾删的时候都要找到最后一个结点，时间复杂度为O(N),并且要考虑到是否为头结点删除起来很不方便。
针对这一些缺点我们再来实现带头双向循环链表，带头双向循环链表结构复杂，一般用在单独存储数据，结构复杂了一点，但是实现起来却很简单。

二、带头双向循环链表实现思路

和前面实现无头单向非循环链表类似，我们也要创建创建一个结点数据类型，里面为数据域和指针域，不过指针域里面要存放上一个结点的地址和下一个结点的地址。

typedef int DataTypedef; //对int类型重新起个名字叫DataType

struct ListNode
{
	DataTypedef data;        //数据域
	struct ListNode* next;   //指针域，存放下一个结点的地址
	struct ListNode* prev;   //指针域，存放上一个结点的地址
};

//对链表类型struct ListNode重新起个名字叫LNode
typedef struct ListNode LNode;

然后有了类型之后我们就在可以创建一个链表类型的指针plist，这个指针用来维护带头双向循环链表的头结点（哨兵位）。
接着用指针plist来维护在堆上开辟的哨兵位结点，但是有一点要非常注意：
要进行传指针plist的地址，不能传指针plist的内容；
因为想要改变指针plist存放的内容就要传指针plist的地址，然后要用二级指针来接收plist的地址，从而解引用来改变指针plist所存的内容，这样才会改变指针plist维护的哨兵位结点。

三、链表指针和结点内存布局图

四、带头双向循环链表的初始化

初始化要开辟一个哨兵位结点，为后面的接口做准备，并且这个哨兵位的结点存放上一个和下一个结点的地址都是自己，这样设计能减少很多麻烦，后面再来分析，我们先实现初始化，代码如下：

//初始化函数
void ListInit(LNode** pphead)
{
	LNode* tmp = (LNode*)malloc(sizeof(LNode));
	if (tmp == NULL)
	{
		perror("erron ");
		exit(-1);
	}

	tmp->next = tmp;
	tmp->prev = tmp;
	tmp->data = 0;
	*pphead = tmp;
}

五、带头双向循环链表接口实现：

1.尾部插入数据

代码实现如下：

//开辟新结点函数
LNode* BuyNewNode(DataTypedef x)
{
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	if (newNode == NULL)
	{
		perror("erron ");
		exit(-1);
	}
	newNode->data = x;
	return newNode;
}

//尾插
void ListPushBack(LNode* phead,DataTypedef x)
{
	assert(phead);
	LNode* newNode = BuyNewNode(x); //开辟一个结点

	//找到最后一个结点,哨兵位的前面就是尾结点
	LNode* tail = phead->prev;

	// tail   newNode  phead;
	//在最后一个结点后面链接一个新的结点
	tail->next = newNode;
	newNode->prev = tail;
	phead->prev = newNode;
	newNode->next = phead;
}

如果实现过无头单向不循环链表，在此过程中我们考虑的情况很多，比如大家肯定会问为什么不考虑链表为空只有一个哨兵位的情况呢？这样特殊的情况还能实现吗？

这里就体现了初始化的时候要把哨兵位的下一个和上一个结点存的是自己地址的好处了，这样设计就算链为空也能实现。大家可以画图分析一下结构设计的非常巧妙。只要有哨兵位在，就不用考虑链表是否为空。这也是对无头单向不循环链表缺点的补充。

2.头部插入数据

//头插
void ListPushFront(LNode* phead, DataTypedef x)
{
	assert(phead);
	LNode* newNode = BuyNewNode(x);
	//先找到第一个结点
	LNode* next = phead->next;

	//phead   newNode   next
	//在哨兵位结点和第一个结点之间插入即可
	phead->next = newNode;
	newNode->prev = phead;
	newNode->next = next;
	next->prev = newNode;
}

3.尾部删除数据

代码实现如下：

//尾删
void ListPopBack(LNode* phead)
{
	assert(phead);
	//要保证链表有结点可以删除，不能删除哨兵位
	assert(phead->next != phead);
	LNode* tail = phead->prev;
	//要找到尾结点的前一个
	LNode* tailPrev = tail->prev;

	//tailPrev  phead
	//把尾结点的前一个和哨兵位连接起来即可
	tailPrev->next = phead;
	phead->prev = tailPrev;
	
	//最后要把尾结点释放掉
	free(tail);
}

4.头部删除数据

代码实现如下：

//头删
void ListPopFront(LNode* phead)
{
	assert(phead);
	//要保证链表有结点可以删除，不能删除哨兵位
	assert(phead->next != phead);

	//找到第二个结点
	LNode* start = phead->next->next;
	//释放掉头结点
	free(phead->next);

	//phead   start
	//把哨兵位和第二个结点连接起来即可
	phead->next = start;
	start->prev = phead;
}

5.显示数据

显示数据把结点里面的数据域打印出来即可，代码如下：

//显示数据
void ListPrint(LNode* phead)
{
	assert(phead);
	//从哨兵位的下一个结点开始遍历
	LNode* cur = phead->next;

	//等于哨兵位就是回到起始点，停止遍历
	while (cur != phead)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

6.查找数据

查找数据域里面的信息，如果相等了就返回改结点的地址，代码如下：

//查找数据
LNode* ListFind(LNode* phead, DataTypedef x)
{
	assert(phead);
	//从哨兵位的下一个结点开始找
	LNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	//找不到就返回空指针
	return NULL;
}

7.在结点前面插入数据

代码如下：

//在结点前面插入
void ListInsert(LNode* pos, DataTypedef x)
{
	assert(pos);
	//找到pos位置前面一个结点
	LNode* posPrev = pos->prev;
	LNode* newNode = BuyNewNode(x);


	//posPrev  newNode  pos
	//在它们之间插入即可
	posPrev->next = newNode;
	newNode->prev = posPrev;
	newNode->next = pos;
	pos->prev = newNode;

}

8.删除当前位置数据

实现代码如下：

//删除当前结点数据
void ListErase(LNode* pos)
{
	assert(pos);
	//找到pos位置前一个和后一个结点
	LNode* posPrev = pos->prev;
	LNode* posNext = pos->next;

	// posPrev   posNext
	//把它们连起来即可
	posPrev->next = posNext;
	posNext->prev = posPrev;
}

9.内存释放

//内存释放
void ListDestroy(LNode** pphead)
{
	assert(pphead);
	//从哨兵位的下一个结点开始释放
	LNode* cur = (*pphead)->next;
	while (cur != *pphead)
	{
		LNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//最后把哨兵位给释放掉
	free(*pphead);
	*pphead = NULL;
}

六、对头插 尾插 头删 尾删的改造

大家可以发现我们的插入和删除函数与头插 尾插 头删 尾删是非常相似的，所以我们可以不必要重新写一个头插 尾插 头删 尾删；我们直接调用插入和删除函数即可。
改造如下：

//尾插
void ListPushBack(LNode* phead,DataTypedef x)
{
	assert(phead);
	
	//在哨兵位结点前面插入就是尾插
	//调用插入函数即可
	ListInsert(phead, x);
}

//头插
void ListPushFront(LNode* phead, DataTypedef x)
{
	assert(phead);
	
	//在哨兵位结点的下一个结点前面插入就是头插
	//直接调用插入函数
	ListInsert(phead->next, x);
}

//尾删
void ListPopBack(LNode* phead)
{
	assert(phead);
	//要保证链表有结点可以删除，不能删除哨兵位
	assert(phead->next != phead);

	//删除哨兵位结点的前面一位就是尾删
	//直接调用删除函数
	ListErase(phead->prev);
}

//头删
void ListPopFront(LNode* phead)
{
	assert(phead);
	//要保证链表有结点可以删除，不能删除哨兵位
	assert(phead->next != phead);

	//删除哨兵位的下一个结点就是头删
	//直接调用删除函数
	
	ListErase(phead->next);
}

这样的改造我们就可以大大的提高我们实现的效率，就可以快速的实现一个带头双向循环链表。

七、总结（附源码）

以上就是带头双向循环链表实现内容了，其中前面我只有把源文件List.c 和测试文件test.c拆开来分析了。如果想要带头双向循环链表的全部内容，阔以移步到gitee上获取

源文件获取地址，点击即可