数据结构：带头双向循环链表

一、链表介绍

前面说到，链表的结构一共有8种：带头单向循环、带头单向非循环、带头双向循环、带头双向非循环、无头单向循环、无头单向非循环、无头双向循环、无头双向非循环。

在这8中结构中，我们只挑两种来剖析：即无头单向非循环和带头双向循环。

 无头单向非循环：结构简单，一般不会用来存储数据。实际上是作为其他数据结构的子结构，入哈希桶、图的链接表等等。此外，这种结构在笔试面试中出现很多。

带头双向循环：结构最复杂，一般用在单独存储数据。实际使用的链表数据都是带头双向循环链表。此外，这个结构虽然复杂，但是使用代码实现以后会发现结构会带来很多有事，实现反而简单了。

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

现在我们来剖析带头双向循环链表：

初始化链表：

首先，我们还是需要先定义一个结点类型，与单向链表相比，双向链表的结点结构中需要多出一个前驱指针，用于指向前面一个结点，实现双向。

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

然后，我们需要一个初始化函数，对双向链表进行初始化，在初始化的过程中，需要申请一个头结点，头结点的前驱和后继指针都指向自己，使得链表一开始便满足循环。

//初始化链表
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(-1);//申请一个头结点，头结点不存储有效数据
	//起始只有头结点，让它的前驱后后继都指向自己
	phead->prev = phead;
	phead->next = phead;
	return phead;
}

//创建一个新节点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	node->data = x;
	node->prev = NULL;
	node->next = NULL;

	return node;
}

---

销毁链表

销毁链表，从头结点的后一个结点处开始向后遍历并释放结点，直到遍历到头结点时，停止遍历并将头结点也释放掉。

void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	ListNode* next = cur->next;
	while (cur!=phead)
	{
		free(cur);
		cur = next;
		next = next->next;
	}
	free(phead);
}

打印双向链表

打印双向链表时也是从头结点的后一个结点处开始向后遍历并打印，直到遍历到头结点处便停止遍历和打印（头结点数据不打印）。

//打印双向链表
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur!=phead)
	{
		printf("%d ",cur->data);
		cur=cur->next;
	}

	printf("\n");
}

查找元素

给定一个值，在链表中寻找与该值相同的结点，若找到了，则返回结点地址；若没有找到，则返回空指针。

//查找元素
ListNode* ListFind(ListNode* phead)
{
	assert(phead);

	ListNode* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data)
		{
			return cur;
		}
		cur->next;
	}
	return NULL;
}

增加结点

头插

头插，即申请一个新节点，将新节点插入在头结点和头结点的后一个结点之间即可。

void ListPushFront(ListNode* phead,LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* front = phead->next;
	//建立新节点与头结点之间的双向关系
	phead->next = newnode;
	newnode->prev = phead;
	//建立新节点与front结点之间的双向关系
	newnode->next = front;
	front->prev = newnode;
}

尾插

尾插，申请一个新节点，将新节点插入到头结点和头结点的前一个结点之间即可。因为链表是循环的，头结点的前驱指针直接指向最后一个结点，所以我们不必遍历链表找尾。

void ListPushBack(ListNode* phead,LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* tail = phead->prev;
	
	//建立新结点与头结点之间的双向关系
	newnode->next = phead;
	tail->next = newnode;

	//建立新结点与tail之间的双向关系
	tail->next = newnode;
    newnode->prev = tail;
}

在指定位置前插入结点

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* before = pos->prev;
	ListNode* newnode = BuyListNode(x);
	//建立新结点与before结点之间的双向关系
	before->next = newnode;
	newnode->prev = before;
	//建立新结点与pos结点之间的双向关系
	newnode->next = pos;
	pos->prev = newnode;
}

删除结点

头删

头删，即释放头结点的后一个结点，并建立头结点与被删除节点的后一个结点之间的双向关系即可。

void ListPopFront(ListNode* phead)
{
	aseert(phead);
	assert(phead->next != phead);

	ListNode* front = phead->next;//记录头结点后的一个结点
	ListNode* newfront = front->next;//记录front结点的后一个结点
	//建立头结点与newfront结点之间的双向关系
	phead->next = newfront;
	newfront->prev = phead;
	free(front);

}

尾删

尾删，即释放最后一个结点，并建立头结点和被删除结点的前一个结点之间的双向关系即可。

void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next!=phead);

	ListNode* tail = phead->prev;//记录头结点的前一个结点
	ListNode* newtail = tail->prev;//记录tail结点的前一个结点
	//建立头结点与newtail结点之间的双向关系
	newtail->next = phead;
	phead->prev = newtail;
	free(tail);//释放tail结点
}

在指定位置删除结点

在指定位置删除结点，释放掉目标结点后，建立该结点前一个结点和后一个结点之间的双向关系即可。

void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* before = pos->prev;
	ListNode* after = pos->next;
	//建立before结点和after结点之间的关系
	before->next = after;
	after->prev = before;
	free(pos);
}

链表判空

链表判空，即判断头结点的前驱或是后继指向的是否是自己即可。

//链表判空
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

获取链表中的元素个数

获取链表中的元素个数，即遍历一遍链表，统计结点的个数（头结点不计入）并返回即可。

int ListSize(ListNode* phead)
{
	assert(phead);
	int count = 0;
	ListNode* cur = phead->next;
	while (cur!=phead)
	{
		count++;
		cur=cur->next；
	}
	return count;
}