【数据结构】双向带头循环链表

前面讲到了单链表，讲解了链表的分类，这里补充一下双向带头循环链表，这两个链表为链表里最典型，使用最多的两个链表，而双向带头循环的链表为链表当中最有的链表，可能看到名字复杂，包含的东西比较多，不理解为什么为最优，下面就给大家解惑

//双向带头循环链表
typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType val;
}ListNode;

因为这里是带头的链表，所以我们第一步先来创建头结点 ，需要注意的是，因为这是一个循环的链表，所以当我们创建头结点的时候，我们头结点的next和prev需要指向自己。

ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	head->next = head;
	head->prev = head;
	return head;
}

老样子，第一步，先写开创结点的功能，毕竟擦汗如数据需要用到，还是封装成函数。

ListNode* BuyListNode(LTDataType x)
{
	struct ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->val = x;
	return newnode;
}

初始化没啥好多说的，建议大家在写代码遇到变量是尽量的初始化，可以避免遇到不必要的问题

ListNode* ListInit(LTDataType x)
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

开创一个新结点在尾部，这里这个链表的优点就体现出来了，前一篇的单链表找尾部时需要遍历一遍直到走到NULL，才能找到，这里由于是双向循环的，所以可以直接找head->prev,也就是头结点的prev指向的结点，就是尾部，然后插入一个结点，并将插入的接结点尾部指向头，头结点也需要指向新的尾。

//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* tail = phead->prev;
	ListNode* newnode = BuyListNode(x);
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

插在头结点后面，注意将链表前后链接起来就行，比较简单，直接上代码。2.4

//头插
void LIstPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* first = phead->next;//要插入的位置
	ListNode* newnode = BuyListNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

 注意前后链接的问题。

//中间插（在pos前面插一个）
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyListNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

还是一样的方便 ，直接找头结点的prev就找到尾巴，然后free点，将前一个和头结点建立关系。需要注意的是，我们需要判断一下，当没有结点的时候能不能删。

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next != NULL);//只有头结点的时候不能删
	ListNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
}

 还是一样，判断一下有没有结点，没有的情况下不能删。

//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(phead->next != NULL);
	ListNode* first = phead->next;
	ListNode* next = first->next;
	free(first);
	phead->next = next;
	next->prev = phead;
}

//中间删(删除pos当前位置)
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

通过结点里面的值val来查找，找到了就返回当前结点的地址，没找到就返回空

//查询
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

打印需要注意迭代结束的条件，当链表走到head时就应该停止。

//打印
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("n");
}