数据结构 -2.3- 带头双向循环链表 | C

链表的分类

1. 单向或双向
2. 带头或不带头（哨兵位）
3. 循环或非循环

组合排序共8种。

• 不带头单向非循环链表（一般称单链表）：结构最简单，操作比较复杂
• 带头双向循环链表：结构复杂，操作简单
  

带头双向循环链表

带头双向循环链表的实现本质上与单链表的差别不大，关于各个函数实现的详细思路见【数据结构初阶】-3-链表 | 链表是什么？| 【单链表的增删查改|思路+源码】

然而，这里有必要提几点注意。

• 双向链表打印ListPrint怎么遍历链表？结束条件是什么？链表的"尾"其实是head->_prev，即当遍历到的结点的next指向头结点即为结束。
• 易错：malloc的时候注意不要写成结构体指针！而是结构体本身！malloc(sizeof(ListNode))
• 统计链表中有效结点的个数（不包括哨兵位）ListSize 可以用哨兵位存长度吗？？不能，因为结点中存储的数据类型不一定是整型，只是这里用的例子是int data，data中不一定能有效的存储整数（结点的个数）。
• 链表结点的空间是依次开辟的，释放的时候也要依次释放。

另外，这种带头双向循环链表一般用于存储数据，一般不用单链表存储。

源码

#include 
#include 
#include 
#include 
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

//创建一个储存有效数据的结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	if (!newNode)
	{
		perror("ListCreate()");
		exit(-1);
	}
	newNode->_data = x;
	newNode->_prev = NULL;
	newNode->_next = NULL;
	return newNode;
}

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (!head)
	{
		perror("ListCreate()");
		exit(-1);
	}
	head->_next = head;
	head->_prev = head;
	return head;
}

// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead;
	ListNode* tail = pHead->_prev;
	while (cur != tail)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(tail);
}

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead;
	while (cur->_next != pHead)
	{
		printf("[ %p | %d | %p ]\n", cur->_prev, cur->_data, cur->_next);
		cur = cur->_next;
	}
	printf("[ %p | %d | %p ]\n", cur->_prev, cur->_data, cur->_next);
}

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	/*ListNode* newtail = BuyListNode(x);
	newtail->_next = pHead;
	newtail->_prev = pHead->_prev;
	pHead->_prev = newtail;
	newtail->_prev->_next = newtail;*/
	ListInsert(pHead, x);
}

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->_prev);

	ListNode* tail = pHead->_prev;
	tail->_prev->_next = pHead;
	pHead->_prev = tail->_prev;
	free(tail);
}

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* newNode = BuyListNode(x);
	newNode->_next = pHead->_next;
	newNode->_prev = pHead;
	pHead->_next = newNode;
	newNode->_next->_prev = newNode;
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListNode* newhead = pHead->_next->_next;
	ListNode* head = pHead->_next;
	pHead->_next = newhead;
	newhead->_prev = pHead;
	free(head);
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
			return cur;
		cur = cur->_next;
	}
	printf("%d未找到！\n", x);
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newlist = BuyListNode(x);
	newlist->_prev = pos->_prev;
	newlist->_next = pos;
	pos->_prev->_next = newlist;
	pos->_prev = newlist;
}
// 双向链表删除pos位置的节点(pos不能是pHead)
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* next = pos->_next;
	ListNode* prev = pos->_prev;
	prev->_next = next;
	next->_prev = prev;
	free(pos);
}

//判空
bool ListEmpty(ListNode* pHead)
{
	assert(pHead);
	return pHead->_next == pHead;
}
//统计链表中有效结点的个数（不包含哨兵位）
size_t ListSize(ListNode* pHead)
{
	size_t count = 0;
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		count++;
		cur = cur->_next;
	}
	return count;
}