双向循环带头链表

虽然这种结构复杂，但是在实现各种操作时有奇效；下面我们就来实现一下它吧！

1.我们先来看一下它的结构；

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;

	LTDataType data;
}LTNode;

2.创建一个新节点在很多操作下都会用到，我们不妨考虑把它封装成一个函数；

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		//return NULL;
		exit(-1);
	}
	node->next = NULL;
	node->prev = NULL;
	node->data = x;

	return node;
}

2.双向链表的初始化；

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

这里为了体现它的特点，双向，循环，带头，需要将它的prev指针和next指针都指向自己；

3.打印

void LTPrint(LTNode* phead)
{
	assert(phead);

	printf("<=head=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

用cur指针从第一个有效数据节点开始遍历，当cur指向phead停止；

4.判空

bool LTEmpty(LTNode* phead)
{
	assert(phead);

	/*if (phead->next == phead)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return phead->next == phead;
}

这个比较简单，无需多言；

5.尾插

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//LTNode* tail = phead->prev;

	 phead            tail  newnode
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

}

这就是优于单链表的一个特点，单链表实现尾插需要寻找尾节点，而双向链表的尾节点就存在头节点的prev指针域里，及tail=phead->prev,而对于双向链表，插入操作要修改四个指针；

6.尾删

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	tailPrev->next = phead;
	phead->prev = tailPrev;
	free(tail);
	tail = NULL;
}

7.头插

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
    1，提前保存地址，防止后来被覆盖找不到；
	//LTNode* newnode = BuyListNode(x);
	//LTNode* first = phead->next;
	//phead->next = newnode;
	//newnode->prev = phead;

	//newnode->next = first;
	//first->prev = newnode;

	2.必须按顺序书写；
	//newnode->next = phead->next;
	//phead->next->prev = newnode;

	//phead->next = newnode;
	//newnode->prev = phead;

	LTInsert(phead->next, x);
}

8.在pos位置之前插入一个新节点；

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);
	// prev newnode pos

	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}

 我们思考一下，头插不就是在第一个节点之前插入吗？

LTInsert(phead->next, x);

 尾插也可以理解为在头节点之前插入（因为是双向循环链表，头节点的前一个就是尾节点）；

LTInsert(phead, x);

怎么样，是不是比单链表实现方便了不少！