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

目录

全部代码

图例（双向带头循环链表）

各个功能的实现

 创建该链表的节点

创建初始链表 

链表的头插

链表的尾插

链表的随机插入

链表的头删

链表的尾删

链表的随机删除

链表的销毁

链表是否为空的判断

链表节点的创建 

总结

---

全部代码

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType val;
	ListNode* next;
	ListNode* prev;
}ListNode;
//判断链表是否为空
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	return !(phead->next == phead);
}
//头删
void ListPopfront(ListNode* phead)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* first = phead->next;
	ListNode* second = first->next;


	phead->next = second;
	second->prev = phead;
}
//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* tail = phead->prev;
	ListNode* prevtail = tail->prev;
	free(tail);
	phead->prev = prevtail;
	prevtail->next = phead;
}
//打印链表
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	printf("哨兵位<<==>>");
	while (cur != phead)
	{
		printf("%d<<==>>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}
//创建链表
ListNode* ListCreate()
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	assert(phead);
	phead->val = -1;
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
//创建新的节点
ListNode* BuyNode(int x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	assert(newnode);
	newnode->val = x;
	newnode->prev = NULL;
	newnode->next = NULL;
	return newnode;
}
//尾插
void PushBack(ListNode* phead,LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyNode(x);
	ListNode* tail = phead->prev;
	newnode->prev = tail;
	tail->next = newnode;
	phead->prev = newnode;
	newnode->next = phead;
}
//头插
void PushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* first = phead->next;
	ListNode* newnode = BuyNode(x);
	newnode->next = first;
	first->prev = newnode;
	newnode->prev = phead;
	phead->next = newnode;
}


//链表的查找
ListNode* ListFind(ListNode* phead, LTDataType pos)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val == pos)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//在pos前面进行插入
void ListInsert(ListNode* phead,LTDataType pos,LTDataType x)
{
	assert(phead);
	ListNode* des = ListFind(phead,pos);
	ListNode* prev = des->prev;
	ListNode* newnode = BuyNode(x);
	newnode->next = des;
	des->prev = newnode;
	newnode->prev = prev;
	prev->next = newnode;
}
//删除目标节点
void ListErase(ListNode* phead, LTDataType pos)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* tail = ListFind(phead,pos);
	ListNode* prev = tail->prev;
	ListNode* next = tail->next;


	prev->next = next;
	next->prev = prev;
	free(tail);
}
//链表的销毁
void DestroyList(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	printf("链表销毁成功\n");
}

图例（双向带头循环链表）

 顾名思义，这种链表有前指针和后指针，并且带有哨兵位，另外也是循环的，这种结构是非常优秀的，增删查改那是嘎嘎顺手。

各个功能的实现

 创建该链表的节点

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

在节点里设置前后两个指针，以达到双向的目的。

创建初始链表 

//创建链表
ListNode* ListCreate()
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	assert(phead);
	phead->val = -1;
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

先创建好哨兵位，并让前后指针都指向哨兵位以完成链表的初始化。

链表的头插

void PushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* first = phead->next;
	ListNode* newnode = BuyNode(x);
	newnode->next = first;
	first->prev = newnode;
	newnode->prev = phead;
	phead->next = newnode;
}

 

assert(phead);：使用 assert() 确认输入的链表头指针不为空。
ListNode* first = phead->next;：将指针 first 指向链表的第一个节点，以备后续将新节点插入到第一个位置。
ListNode* newnode = BuyNode(x);：使用函数 BuyNode() 创建值为 x 的新节点，该函数的实现不在此代码段中。
newnode->next = first;：将新节点的 next 指针指向原来的第一个节点。
first->prev = newnode;：将原来的第一个节点的 prev 指针指向新节点。
newnode->prev = phead;：将新节点的 prev 指针指向链表头节点，即使它成为了链表的第一个节点。
phead->next = newnode;：将链表头节点的 next 指针指向新的第一个节点，完成插入操作。

整个过程可以描述为：创建一个新节点，将其 next 指针指向原来的第一个节点，将原来的第一个节点 prev 指针指向新节点，将新节点 prev 指针指向链表头节点，最后将链表头节点的 next 指针指向新节点。这就将新节点插入到了链表的头部位置。

链表的尾插

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

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
ListNode* newnode = BuyNode(x);：使用函数 BuyNode() 创建值为 x 的新节点，该函数的实现不在此代码段中。
ListNode* tail = phead->prev;：将指针 tail 指向链表的最后一个节点，以备后续将新节点插入到最后一个位置。
newnode->prev = tail;：将新节点的 prev 指针指向原来的最后一个节点。
tail->next = newnode;：将原来的最后一个节点的 next 指针指向新节点。
phead->prev = newnode;：将链表头节点的 prev 指针指向新的最后一个节点，即使它成为了链表的尾部节点。
newnode->next = phead;：将新节点的 next 指针指向链表头节点，完成插入操作。
整个过程可以描述为：创建一个新节点，将其 prev 指针指向原来的最后一个节点，将原来的最后一个节点 next 指针指向新节点，将链表头节点的 prev 指针指向新的最后一个节点，最后将新节点的 next 指针指向链表头节点。这就将新节点插入到了链表的尾部位置。

链表的随机插入

void ListInsert(ListNode* phead,LTDataType pos,LTDataType x)
{
	assert(phead);
	ListNode* des = ListFind(phead,pos);
	ListNode* prev = des->prev;
	ListNode* newnode = BuyNode(x);
	newnode->next = des;
	des->prev = newnode;
	newnode->prev = prev;
	prev->next = newnode;
}

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
ListNode* des = ListFind(phead,pos);：使用函数 ListFind() 找到值为 pos 的节点，该函数的实现不在此代码段中。
ListNode* prev = des->prev;：将指针 prev 指向目标节点的前一个节点。
ListNode* newnode = BuyNode(x);：使用函数 BuyNode() 创建值为 x 的新节点，该函数的实现不在此代码段中。
newnode->next = des;：将新节点的 next 指针指向目标节点。
des->prev = newnode;：将目标节点的 prev 指针指向新节点。
newnode->prev = prev;：将新节点的 prev 指针指向目标节点的前一个节点。
prev->next = newnode;：将目标节点的前一个节点的 next 指针指向新节点。
整个过程可以描述为：通过查找函数 ListFind() 在链表中找到值为 pos 的节点 des，创建一个新节点，将其 next 指针指向目标节点 des，将目标节点 des 的 prev 指针指向新节点，将新节点 next 指针指向目标节点的前一个节点 prev，最后将前一个节点 prev 指针指向新节点。这就将新节点插入到了指定位置 pos 前面的位置。

链表的头删

//头删
void ListPopfront(ListNode* phead)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* first = phead->next;
	ListNode* second = first->next;

	phead->next = second;
	second->prev = phead;
}

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
assert(ListEmpty(phead));：使用 ListEmpty() 函数确认链表不为空，如果链表为空，则终止程序。
ListNode* first = phead->next;：将指针 first 指向链表的第一个节点，以备后续删除该节点。
ListNode* second = first->next;：将指针 second 指向链表中的第二个节点，以备后续将其和链表头连接。
phead->next = second;：将链表头的 next 指针指向第二个节点。
second->prev = phead;：将第二个节点的 prev 指针指向链表头，完成删除操作。
整个过程可以描述为：将链表头的 next 指针指向第二个节点，将第二个节点的 prev 指针指向链表头，即可将原来的第一个节点删除。

链表的尾删

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* tail = phead->prev;
	ListNode* prevtail = tail->prev;
	free(tail);
	phead->prev = prevtail;
	prevtail->next = phead;
}

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
assert(ListEmpty(phead));：使用 ListEmpty() 函数确认链表不为空，如果链表为空，则终止程序。
ListNode* tail = phead->prev;：将指针 tail 指向链表的最后一个节点，以备后续删除该节点。
ListNode* prevtail = tail->prev;：将指针 prevtail 指向原先链表的倒数第二个节点，以备后续处理将其作为尾节点。
free(tail);：释放节点 tail 的内存空间。
phead->prev = prevtail;：将链表头的 prev 指针指向 prevtail，表示现在 prevtail 成为了新的尾节点。
prevtail->next = phead;：将 prevtail 的 next 指针指向链表头节点，即将原先的最后一个节点与链表头连接。
整个过程可以描述为：找到链表末尾的节点 tail，将其前一个节点 prevtail 作为新的尾节点，通过释放 tail 的内存空间将其从链表中删除，最后将新的尾节点 prevtail 和链表头连接起来。

链表的随机删除

void ListErase(ListNode* phead, LTDataType pos)
{
	assert(phead);
	assert(ListEmpty(phead));
	ListNode* tail = ListFind(phead,pos);
	ListNode* prev = tail->prev;
	ListNode* next = tail->next;

	prev->next = next;
	next->prev = prev;
	free(tail);
}

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
assert(ListEmpty(phead));：使用 ListEmpty() 函数确认链表不为空，如果链表为空，则终止程序。
ListNode* tail = ListFind(phead,pos);：使用 ListFind() 函数查找并返回值为 pos 的节点 tail，该函数的实现不在此代码段中。
ListNode* prev = tail->prev;：将指针 prev 指向目标节点 tail 的前一个节点。
ListNode* next = tail->next;：将指针 next 指向目标节点 tail 的后一个节点。
prev->next = next;：将指向目标节点 tail 的前一个节点的 next 指针指向目标节点 tail 的下一个节点 next。
next->prev = prev;：将目标节点 tail 的后一个节点的 prev 指针指向目标节点 tail 的前一个节点 prev。
free(tail);：释放目标节点的内存空间。
整个过程可以描述为：通过查找函数 ListFind() 在链表中找到值为 pos 的节点 tail，将其前一个节点 prev 和后一个节点 next 分别指向 tail 的前一个节点和后一个节点，最后通过释放 tail 的内存空间将其从链表中删除。

链表的销毁

//链表的销毁
void DestroyList(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	printf("链表销毁成功\n");
}

 assert(phead);：使用 assert() 确认输入的链表头指针不为空。
ListNode* cur = phead->next;：将指针 cur 指向链表的第一个节点，以备后续依次释放每一个节点的内存空间。
while (cur != phead)：当 cur 不指向链表头节点时，执行以下代码块。
ListNode* next = cur->next;：将指针 next 指向当前节点的下一个节点，以备后续依次释放每一个节点的内存空间。
free(cur);：释放当前节点的内存空间。
cur = next;：将指针 cur 指向链表的下一个节点，以便继续删除链表的下一个节点。
free(phead);：释放链表头节点的内存空间。
printf("链表销毁成功\n");：输出提示信息，表示链表销毁成功。
整个过程可以描述为：从链表的第一个节点开始，通过循环依次释放每一个节点的内存空间，直到删除链表头节点为止。最后输出提示信息，表示链表销毁成功。

链表是否为空的判断

//判断链表是否为空
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	return !(phead->next == phead);
}

 

assert(phead);：使用 assert() 确认输入的链表头指针不为空。
return !(phead->next == phead);：判断链表是否为空，如果 phead 的下一个节点指向链表头自身，则返回 false，表示该链表为空；否则返回 true，表示该链表不为空。

整个过程可以描述为：判断链表头节点 phead 的下一个节点是否指向链表头节点自身，如果是，则该链表为空，返回 false；否则说明该链表不为空，返回 true。
 

链表节点的创建 

//创建新的节点
ListNode* BuyNode(int x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	assert(newnode);
	newnode->val = x;
	newnode->prev = NULL;
	newnode->next = NULL;
	return newnode;
}

ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));：使用 malloc() 函数为新节点分配一段内存空间，并将分配的空间强制转换为 ListNode 类型的指针，保存在指针变量 newnode 中。
assert(newnode);：使用 assert() 确认内存分配是否成功，如果分配失败，则终止程序。
newnode->val = x;：将新节点的值设置为 x。
newnode->prev = NULL;：将新节点的前驱指针 prev 指向 NULL。
newnode->next = NULL;：将新节点的后继指针 next 指向 NULL。
return newnode;：返回新创建的节点的指针。
整个过程可以描述为：使用 malloc() 函数为新节点分配一段内存空间，并将新节点的值及前驱/后继指针初始化为 NULL，最后返回新节点的指针。

总结

介绍了带头双向链表的实现，实现了头插、头删、尾插、尾删、随机插入、随机删除、链表的创建、链表的销毁等功能。