一：

链表分为八大类，此篇讲述的带头节点双向循环链表的实现；

此类链表物理结构如下图：

每个节点内有2个指针，分别指向前一个节点和下一个节点；

当链表没有内容时头节点如下所示：

头节点的好处是进行插入或删除第一个节点时不用考虑特殊情况；

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?对比单链表，带头链表的好处时进行头插头删时不必使用二级指针；

二、实现：

????????

typedef struct LIST
{
	struct LIST* prev;
	struct LIST* next;
	int data;
}LIST;

2，初始化

为了避免使用二级指针，于是就进行函数嵌套；头节点的初始化就完成了

LIST* head = BuyHead();

LIST* BuyNode(int x)//开辟新节点
{
	LIST* newnode = (LIST*)malloc(sizeof(LIST));
	if (newnode == NULL)
		return NULL;
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}


LIST* BuyHead()
{
	LIST* head = BuyNode(0);
	head->next = head;
	head->prev = head;
	return head;
}

3,头增

????????????????

?如图所示，头增就是在头节点的后面增加一个节点，改变原先节点的链接；

void Hnode(LIST* phead,int x)//头增
{
	assert(phead);
	LIST* newnode = BuyNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

该函数可以不用在意节点的链接顺序；也不必在意链表是否没有元素

?当链表为空时，head->next就等于它本身；体现出带头链表的好处

4，尾增

void Wnode(LIST* phead, int x)//尾
{
	LIST* newnode = BuyNode(x);
	LIST* replica = phead->prev;
	replica->next = newnode;
	newnode->prev = replica;
	newnode->next = phead;
	phead->prev = newnode;


}

5，头删

void DenHnode(LIST* phead)//头删
{

	assert(phead);
	assert(phead->next != phead);
	LIST* replica = phead->next;
	replica->next->prev = phead;
	phead->next = replica->next;
	free(replica);
	replica = NULL;


}

在删除元素时要考虑到链表是否为空，节点是否为空，用assert断言；

6，尾删

void DenWnode(LIST* phead)//尾删
{
	assert(phead);
	assert(phead->prev != phead);
	LIST* replica = phead->prev;
	phead->prev = replica->prev;
	replica->prev->next = phead;
	free(replica);
	replica = NULL;

}

7，查找


LIST* SeekList(LIST* head, int x)//查找
{
	assert(head);
	LIST* replica = head->next;
	while (replica != head)
	{
		if (replica->data == x)
		{
			return replica;
		}
		replica = replica->next;
	}
	return NULL;
}

8，删除指定元素

void SpDen(LIST* cop)//删除指定元素
{
	LIST* prev = cop->prev;
	LIST* next = cop->next;
	prev->next = next;
	next->prev = prev;
	free(cop);
	cop = NULL;
}

9.在cop前增加元素

void SpAdd(LIST* cop,int x)
{
	LIST* newnode = BuyNode(x);
	LIST* replica = cop->prev;
	replica->next = newnode;
	newnode->prev = replica;
	newnode->next = cop;
	cop->prev = newnode;


}

思考8和9，如果把cop换成第一个元素或最后一个元素是否可以完成头，尾删，头，尾增；

答案是可以的，

头删，增；把cop替换成phead->next，

尾删，增：把cop替换成phead->prev；

10.打印

void Print(LIST* phead)//打印
{
	LIST* replica = phead->next;
	
	while (replica != phead)
	{
		printf("%d ", replica->data);
		replica = replica->next;
	}
	printf("\n");
}