【数据结构】单链表升级——带头双向循环链表

原创已于 2023-03-29 18:04:11 修改 · 310 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #链表

于 2023-03-26 22:59:39 首次发布

逐步刨析，深入了解之数据结构专栏收录该内容

6 篇文章

订阅专栏

本文介绍了带头双向循环链表的基本知识，包括其结构和数据操作，并提供了初始化、头插、头删、判空及销毁等关键操作的C语言代码实现。文章还包含了完整的代码示例和测试用例，帮助读者理解和掌握双向循环链表的实现。

我有所爱鹤，毛羽霜雪妍。 ——元稹

一、带头双向循环链表

1.1基本知识

循环链表是链表的一种形式，而带头则是指链表中多了一个哨兵位的节点。其结构如下

同样，双向循环链表的实现方式与单链表基本无异，只是多了一个指向前一个位置的prev指针。

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;//哨兵位
	LTDataType data;
}LTNode;

1.2链表的数据操作

双向循环链表的功能与单链表无异，并且虽然该链表看起来结构更加复杂，但实现方式却比单链表容易很多。

二、代码实现

由于双链表实现较为简单，因此在这里只提出需要注意的地方，其余的大家可以直接看代码或者参考上一节单链表的内容：https://hehelm.blog.youkuaiyun.com/article/details/129780396

2.1初始化

双向循环链表的初始化首先要清楚初始化的样子是什么。

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);//返回-1到主函数，结束程序
	}
	node->next = NULL;//初始化
	node->prev = NULL;
	node->data = x;
	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(1);
	phead->next = phead;//自循环
	phead->prev = phead;
	return phead;
}

2.2头插&头删

由于双向循环链表的插入删除操作类似，因此只将头插头删进行简单概要。而插入操作都可以由同一函数完成，因此STInsert函数将作为插入的重点

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);

	prev->next = newnode;//前一个的下一个
	newnode->prev = prev;

	newnode->next = pos;//newnode的下一个
	pos->prev = newnode;
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);//要注意，STInsert是在pos位置前插入
}

而删除也较为简单，但是要控制好prev指针和next指针，防止出现“野”的现象。

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

	LTNode* tail = phead->prev;//头的哨兵位指向尾
	LTNode* tailPrev = tail->prev;//tail的哨兵位指向前一个位置

	tailPrev->next = phead;
	phead->prev = tailPrev;

	free(tail);
	tail = NULL;
}

2.3判空&销毁

双向循环链表判空很简单，判断是否首尾相同即可。

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead; //为空首尾相同
}

而销毁也只需从头遍历释放即可。

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* head = phead;
	LTNode* cur = phead->next;
	while (cur!=head)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(head);
	head = NULL;
}

2.4完整代码实现

//List.h

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

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

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;//哨兵位
	LTDataType data;
}LTNode;

LTNode* LTInit();
void LTDestroy(LTNode* phead);
void LTPrint(LTNode* phead);
bool LTEmpty(LTNode* phead);

void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);

void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);

LTNode* LTFind(LTNode* phead, LTDataType x);
void LTInsert(LTNode* pos, LTDataType x);
void LTErase(LTNode* pos);

//List.c

#include "List.h"

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);//返回-1到主函数，结束程序
	}
	node->next = NULL;//初始化
	node->prev = NULL;
	node->data = x;
	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(1);
	phead->next = phead;//自循环
	phead->prev = phead;
	return phead;
}

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* head = phead;
	LTNode* cur = phead->next;
	while (cur!=head)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(head);
	head = NULL;
}

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

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead; //为空首尾相同
}

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

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

	LTNode* tail = phead->prev;//头的哨兵位指向尾
	LTNode* tailPrev = tail->prev;//tail的哨兵位指向前一个位置

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

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}

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

	LTNode* cur = phead->next;
	phead->next = phead->next->next;
	phead->next->prev = phead;


	free(cur);
	cur = NULL;

}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);

	prev->next = newnode;//前一个的下一个
	newnode->prev = prev;

	newnode->next = pos;//newnode的下一个
	pos->prev = newnode;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	if (phead == NULL)
	{
		return;
	}
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

void LTErase(LTNode* pos)
{
	assert(pos);
	assert(!LTEmpty(pos));

	LTNode* cur = pos;
	cur->prev->next = cur->next;
	cur->next->prev = cur->prev;
	free(cur);
	cur = NULL;
}

//Test.c

#include "List.h"

int main()
{
	LTNode* ST =LTInit();
	LTPrint(ST);
	LTPushBack(ST, 1);
	LTPushBack(ST, 2);
	LTPushBack(ST, 3);
	LTPushBack(ST, 4);
	LTPushBack(ST, 5);
	LTPrint(ST);
	LTPushFront(ST, -1);
	LTPrint(ST);
	LTPopBack(ST);
	LTPopFront(ST);
	LTPrint(ST);
	LTNode* ret = LTFind(ST, 3);
	LTErase(ret);
	LTPrint(ST);

}

运行结果