带头双向循环链表实现

 双向循环链表是由链表中的，循环链表与双向链表和有哨兵位共同构成

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int LTDataType;


typedef struct LTNode
{
	LTDataType data;
	struct LTNode* next;
	struct LTNode* prev;
}LTNode;
//初始化头结点
LTNode* LTInit();
//打印链表
void LTPrint(LTNode* head);
//链表尾插
void LTPushBack(LTNode* head, LTDataType x);
//链表尾删
void LTPopBack(LTNode* head);
//链表头插
void LTPushFront(LTNode* head,LTDataType x);
//链表头删
void LTPopFront(LTNode* head);
//链表查找
LTNode* LTFind(LTNode* head, LTDataType x);
//链表pos之前插入
void LTInsert(LTNode* pos, LTDataType x);
//链表pos之后插入
void LTErase(LTNode* pos);
//销毁双向链表
void LTDestroy(LTNode** head);
//打印双向链表
void LTPrint(LTNode* head);

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* Node = NULL, * Head = NULL;
	Node = (LTNode*)malloc(sizeof(LTNode));
	if (Node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	Head = Node;
	Head->data = x;
	Head->next = NULL;
	Head->prev = NULL;
}
//创建头结点
LTNode* LTInit()
{
	LTNode* head = BuyLTNode(-1);
	head->next=head;
	head->prev = head;
	return head;
}
//链表是否为空
bool LTEmpty(LTNode* head)
{
	assert(head);
	return head->next == head;
}
//打印链表
void LTPrint(LTNode* head)
{
	assert(head);
	assert(!LTEmpty(head));
	printf("Head -> ");
	LTNode* Node = head->next;
	while (Node != head)
	{
		printf("%d <-> ", Node->data);
		Node = Node->next;
	}
	printf("\n");
}


//尾插
void LTPushBack(LTNode* head,LTDataType x)
{
	assert(head);
	//双向带头循环头结点prev指向尾节点
	LTNode* Newhead = head;
	LTNode* Node=BuyLTNode(x);
	Node->prev = Newhead->prev;
	Node->prev->next = Node;
	Node->next = Newhead;
	Newhead->prev = Node;
}
//尾删
void LTPopBack(LTNode* head)
{
	assert(head);
	assert(!LTEmpty(head));
	LTNode* tail = NULL, * tailprev = NULL;
	//存储为节点的尾节点的信息
	tail = head->prev;
	//存储tail前一个节点的地址
	tailprev = tail->prev;
	//链接新尾节点
	head->prev = tailprev;
	tailprev->next = head;
	//释放尾节点
	free(tail);


}
//链表的头插
void LTPushFront(LTNode* head, LTDataType x)
{
	assert(head);
	LTNode* Node=NULL, * Newhead=NULL;
	Node = BuyLTNode(x);
	Newhead = head->next;
	Node->next = Newhead;
	Newhead->prev = Node;
	Node->prev = head;
	head->next = Node;
}
//链表的头删
void LTPopFront(LTNode* head)
{
	assert(head);
	assert(!LTEmpty(head));
	LTNode* Newhead = NULL, * Front = NULL;
	Front = head->next;
	Newhead = Front->next;
	Newhead->prev = head;
	head->next = Newhead;
	free(Front);
}
//链表查找
LTNode* LTFind(LTNode* head, LTDataType x)
{
	LTNode* Newhead = head->next;
	while (Newhead != head)
	{
		if (Newhead->data == x)
		{
			return Newhead;
		}
		Newhead = Newhead->next;
	}
	return NULL;
}
//pos前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* Node = BuyLTNode(x);
	LTNode* posprev = pos->prev;
	posprev->next = Node;
	Node->prev = posprev;
	Node->next = pos;
	pos->prev = Node;
}
//pos位置删除
void LTErase(LTNode* pos)
{
	assert(pos);
	//记录pos前后
	LTNode* pprev = pos->prev, * pnext = pos->next;
	pprev->next = pnext;
	pnext->prev = pprev;
	free(pos);
}
//销毁
void LTDestroy(LTNode** head)
{
	LTNode* cur =  ( * head)->next;
	while (cur!=*head)
	{
		//存储下一个节点
		LTNode* node = cur->next;
		//释放
		free(cur);
		//跳转到下个节点
		cur = node;
	}
	free(*head);
	*head = NULL;
}