C语言详解如何实现带头双向循环链表

typedef int ListDataType;//将ListDataType先定义为int类型，根据需要可以改为不同的类型
//创建一个链表的结构体
typedef struct ListNode
{
	ListDataType data;//存储数据
	struct ListNode* next;//存储下一个结点的地址的指针
	struct ListNode* prev;//存储上一个结点的地址的指针
}ListNode;

ListNode* BuyListNode(ListDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));//向内存申请一个新的结点
	if (newnode == NULL)
	{
		printf("BuyListNode::%s\n", strerror(errno));//打印结点空间申请失败的原因
		exit(-1);//终止程序
	}
	newnode->data = x;//将x放入申请的结点数据区
	newnode->next = NULL;//让新结点的next指向空
	newnode->prev = NULL;//让新结点的prev指向空
	return newnode;//返回新结点的地址
}

void ListInit(ListNode** pphead)//这里我们需要对头结点进行改变，所以传二级指针
{
	assert(pphead);//检测传过来的pphead的地址是否为空
	*pphead = BuyListNode(0);//创建一个新的哨兵位头结点
	(*pphead)->next = *pphead;//让这个结点指向自己
	(*pphead)->prev = *pphead;
}

ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);//创建一个新的哨兵位头结点
	phead->next = phead;//让这个结点的next指向自己
	phead->prev = phead;//让prev指向自己
	return phead;//返回哨兵位头结点的地址
}

void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;//让cur指向哨兵位的下一个结点
	while (cur != phead)//链表打印是否结束的条件判断
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void ListPushBack(ListNode* phead, ListDataType x)
{
	assert(phead);//检查传过来的头结点是否为空
	ListNode* tail = phead->prev;//找到链表的尾结点
	ListNode* newnode = BuyListNode(x);//创建一个新的结点

	tail->next = newnode;//让尾结点的next指向新的结点
	newnode->prev = tail;//让新结点的prev指向之前的尾结点
	newnode->next = phead;//让新的结点的next指向头结点
	phead->prev = newnode;//让头结点指向新的尾结点
}

void ListPopBack(ListNode* phead)
{
	assert(phead);
	if (phead->next == phead)//如果链表只有哨兵位结点的情况，就不能继续删除了
		return;

	ListNode* tail = phead->prev;//找到尾结点
	ListNode* tailPrev = tail->prev;//定义尾结点的前一个结点
	free(tail);//释放要删除的结点
	tailPrev->next = phead;//让前一个结点指向哨兵位结点
	phead->prev = tailPrev;//让哨兵位结点指向新的尾结点
}

void ListPushFront(ListNode* phead, ListDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);//创建一个新结点
	newnode->next = phead->next;//新结点的next指向头结点的下一个结点
	phead->next->prev = newnode;//头结点的下一个结点指向新结点
	phead->next = newnode;//头结点指向新结点
	newnode->prev = phead;//新结点prev指向头结点
}

void ListPushFront(ListNode* phead, ListDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);//创建一个新结点
	ListNode* next = phead->next;//定义next记录头节点的下一个结点的位置
	phead->next = newnode;//头结点next指向新结点
	newnode->prev = phead;//新结点的prev指向头结点
	next->prev = newnode;//头结点的下一个结点的prev指向新阶段
	newnode->next = next;//新结点的next指向原头结点的下一个结点
}

void ListPopFront(ListNode* phead)
{
	assert(phead);
	if (phead->next == NULL)//只有哨兵位头结点的情况
		return;
	ListNode* next = phead->next->next;//定义next指向要删除结点的下一个结点
	free(phead->next);//释放要删除的结点
	phead->next = next;//让哨兵位头结点指向要删除的下一个结点
	next->prev = phead;//让要删除的下一个结点的prev指向toujied
}

ListNode* ListFind(ListNode* phead, ListDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;//让cur指向哨兵位头结点的下一个结点
	while (cur != phead)//链表循环是否结束的判断条件
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;//找不到对于的结点
}

void ListInsert(ListNode* pos, ListDataType x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);//创建一个新的结点
	pos->prev->next = newnode;//pos的前一个结点的next指向新结点
	newnode->prev = pos->prev;//新结点的prev指向pos的前一个结点
	newnode->next = pos;//新结点的next指向pos结点
	pos->prev = newnode;//pos的prev指向新结点
}

void ListInsert(ListNode* pos, ListDataType x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);//创建一个新的结点
	ListNode* posPrev = pos->prev;//定义pos的前一个结点
	posPrev->next = newnode;//让pos的pos前一个结点的next指向新结点
	newnode->prev = posPrev;//新结点的prev指向pos的前一个结点
	newnode->next = pos;//新结点的next指向pos
	pos->prev = newnode;//pos的prev指向新结点
}

void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev;//prev为pos的前一个结点
	ListNode* next = pos->next;//next为pos的后一个结点
	free(pos);//释放posjied
	prev->next = next;
	next->prev = prev;
}

void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;//指向哨兵位结点的下一个结点
	while (cur != phead)//依次循环找链表的每一个结点
	{
		ListNode* next = cur->next;//记录cur的下一个结点位置
		free(cur);//释放cur位置的结点
		cur = next;//指向下一个结点
	}
	free(phead);//释放哨兵位头结点
}