双向带头循环链表的简易实现

双向带头链表图示结构

双向带头循环链表是一种特殊的链表数据结构，具有以下特点：

1. 双向性：每个节点除了包含指向后继节点的指针（通常称为"next"指针）外，还包含指向前驱节点的指针（通常称为"prev"指针）。这使得在链表中可以按照两个方向进行遍历或操作。

2. 带头节点：链表的第一个节点称为头节点，它不存储任何数据，仅作为链表的起点。带头节点的存在简化了链表的操作，避免了一些边界情况的处理。

3. 循环性：链表的最后一个节点的"next"指针指向头节点，而头节点的"prev"指针指向链表的最后一个节点，形成了一个循环。

双向带头循环链表在数据结构中一般用于需要频繁插入、删除节点的场景，因为它具有以下优点：

1. 插入和删除的操作复杂度为O(1)：由于双向性，可以轻松地找到要插入或删除的节点，并且只需修改几个指针的指向即可完成操作。

2. 可以在链表的两个方向上遍历：通过"next"指针可以从头节点开始向后遍历整个链表，通过"prev"指针可以从最后一个节点向前遍历整个链表。

3. 可以实现循环操作：由于链表形成了一个循环，可以方便地实现循环队列或循环列表等特殊结构。

需要注意的是，双向带头循环链表相比于单向链表会占用更多的内存空间，因为每个节点需要额外存储一个"prev"指针。在实际应用中，需要权衡双向性带来的操作便利和空间消耗。

结构体的实现

需要一个前驱指针，后一个后续指针来实现双向遍历。

typedef int LTDataType;

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

接口实现

双向循环带头链表的一些必要接口，如下所示，我们来实现一下。

//头节点的初始化
LTNode* LTInit();
//链表的打印
void LTPrint(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);
//任意位置的插入
void LTInsert(LTNode* pos, LTDataType x);
//查找链表
LTNode* LTFind(LTNode* phead, LTDataType x);
//任意位置的删除
void LTErase(LTNode* pos);
//链表的销毁
void LTDestroy(LTNode* phead);

初始化

由于我们是带头链表，也就是有一个哨兵位的链表，那么我们就创建一个头节点，不存储数据，前驱和后继指针都先指向自己。

LTNode* CreateLTNode(LTDataType x)//节点创建函数
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));//动态开辟该结构体大小的空间充当节点
	if (newnode == NULL)//检查开辟是否成功
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;//存储数据
	newnode->next = NULL;//前驱后继分别指向空指针等待调用
	newnode->prev = NULL;
	return newnode;//返回开辟的该节点
}
LTNode* LTInit()//初始化节点
{
	LTNode* phead = CreateLTNode(-1);//初始化
	phead->next = phead;//前驱后继分别指向自己
	phead->prev = phead;

	return phead;//返回哨兵位
}

在这里需要一个创建节点的函数，我们将其单独封装起来，调用即可，也可看详细注释。

打印链表

我们插入一些数据后，无法查看，所以我们先写一个打印函数让我们能够查看插入情况，当然也可以通过调试的监视窗口进行查看

void LTPrint(LTNode* phead)//打印函数，传入参数类型为节点
{
	assert(phead);//断言非空
	printf("phead<->");//打印链接号

	LTNode* cur = phead->next;//头节点无需打印，从头节点后的第一个节点开始打印
	while (cur != phead)//当遍历至头节点时，循环停止，打印结束
	{
		printf("%d<->", cur->val);//打印链表
		cur = cur->next;//链表移动
	}
	printf("phead");//尾指针指向头节点，因为是循环链表
	printf("\n");//换行
}

实现起来十分简单，详细看注释即可。

尾插

首先依然是断言非空，我们可以知道首先要找到这个插入的节点的位置是尾部，就是头节点的前驱节点，所有用tail节点来存储这个位置的节点，新插入的节点设置为newnode结点，所以tail是原来的尾节点，newnode为新的尾部节点，那么我们就让tail->next指向newnode即可，那么newnode的前驱节点自然也就是原来的尾部节点，所以newnode->prev指向tail节点，这样的话那么就需要更新头节点的前驱节点，后newnode的后继节点，所以我们让newnode->next指向头节点，phead->prev指向新的尾部节点也就是newnode节点。

void LTPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);//断言非空

	LTNode* tail = phead->prev;//找到原来的尾部节点
	LTNode* newnode = CreateLTNode(x);//新插入的节点
	tail->next = newnode;//原来的尾部节点的后继指向新的尾部节点
	newnode->prev = tail;//那么新的尾部节点的前驱指向原来的尾部节点
	newnode->next = phead;//新的尾部节点的后继指向头节点
	phead->prev = newnode;//头结点的前驱则指向新的尾部节点
}

尾删

首先依然断言非空，删除的结点是尾部节点，所以我们通过头节点的前驱指针找到尾部节点，将其记录为tail节点，我们还要记录删除之后新的尾部节点，也就是tail的前驱节点记录为tailprev，所以我们直接free掉tail，并将其赋值为空指针，之后让新的尾部节点tailprev->next指向头节点，以及phead->prev指向新的尾部节点tailprev。

void LTPopBack(LTNode* phead)//尾删
{
	assert(phead);//断言非空
	assert(phead->next);//断言是否仅有头节点
	LTNode* tail = phead->prev;//记录原来的尾部节点
	LTNode* tailprev = tail->prev;//记录新的尾部节点
	free(tail);//释放原来的尾部节点
	tail = NULL;//并将其赋值为空指针
	tailprev->next = phead;//连接好新的尾部节点与头节点的链接关系
	phead->prev = tailprev;
}

头插

首先断言非空之后，我们找插入的位置记录为tail，也就是原来的头节点之后的第一节点，我们要插入的newnode是新的头节点之后的第一节点，那么就很好链接了，newnode->next指向原来的第一节点，现在的第二节点tail节点，newnode->prev指向头节点成为新的第一节点，头节点的后继指向新的第一节点，原来的第一节点也就是现在的第二节点的前驱指向新的第一节点，那么就连接好了。

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);//断言非空
	LTNode* newnode = CreateLTNode(x);//插入的节点
	LTNode* tail = phead->next;//记录原来的第一节点
	newnode->next = tail;//新的第一节点后继指向原来的第一节点
	newnode->prev = phead;//新的第一节点的前驱指向头节点
	phead->next = newnode;//头节点的后继指向新的第一节点
	tail->prev = newnode;//原来的第一节点的前驱指向新的第一节点
}

头删

断言非空之后，我们找到通过头节点的后继第一节点记录为tail节点，同时也要记录新的第一节点也就是第二节点记录为tailnext节点，之后我们free掉tail节点，并将其赋值为空指针，之后连接好头节点与新的第一节点的关系就好了

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next);
	LTNode* tail = phead->next;
	LTNode* tailnext = tail->next;
	free(tail);
	tail = NULL;
	phead->next = tailnext;
	tailnext->prev = phead;
}

查找

查找首先需要传入头节点，和查找的值，通过phead->next找到第一节点从第一节点开始遍历查找，如果找到，我们返回这个节点，循环结束条件为不能是头节点，如果循环结束了，就代表没有这个值的节点，返回空指针。

LTNode* LTFind(LTNode* phead, LTDataType x)//查找函数
{
	assert(phead);//断言非空
	LTNode* cur = phead->next;//从第一节点开始遍历
	while (cur!=phead)//遍历循环
	{
		if (cur->val == x)//如果找到则返回该节点
		{
			return cur;
		}
		cur = cur->next;//指针向后移动
	}
	return NULL;//没有找到返回空指针
}

任意位置插入

首先断言该位置不为空，之后记录该位置的前驱节点，记录新节点为newnode，之后让pos前驱位置的后继指向新的pos位置的节点也就是newnode节点，那么newnode的前驱指向pos前驱的节点成为新的pos位置节点，newnode->next指向pos位置，pos位置的前驱在指向newnode即可。

void LTInsert(LTNode* pos, LTDataType x)//任意位置插入
{
	assert(pos);//断言非空

	LTNode* posPrev = pos->prev;//记录pos位置的前驱节点
	LTNode* newnode = CreateLTNode(x);//新的pos位置节点

	// posprev newnode pos
	posPrev->next = newnode;//pos前驱节点的后继指向新的pos位置节点也就是newnode节点
	newnode->prev = posPrev;//新的pos位置节点的前驱指向posprev
	newnode->next = pos;//新的pos位置节点的后继指向原来的pos节点
	pos->prev = newnode;//原来的pos节点的前驱指向新的pos位置节点
}

任意位置删除

首先断言非空，之后我们记录pos位置的前驱和后继为posprev和posnext，之后我们连接好这两个节点，最后free掉pos位置即可。

void LTErase(LTNode* pos)
{
	assert(pos);//断言非空
	LTNode* posprev = pos->prev;//记录pos位置前驱和后继
	LTNode* posnext = pos->next;
	posprev->next = posnext;//链接好pos位置的前驱和后继
	posnext->prev = posprev;
	free(pos);//释放掉pos并赋值为空指针
	pos = NULL;
	
}

销毁链表

当链表使用完销毁的时候，传入头节点，断言非空，之后记录第一节点，从第一节点开始循环free并且赋值为空指针，指针移动，当移动到头节点的时候停止遍历，释放掉头节点，并将其赋值为空指针。

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

顺序表和链表的区别

顺序表和链表是两种常见的数据结构，它们在存储和操作数据上有以下不同点：

1. 存储方式：顺序表通过一段连续的内存空间来存储数据，而链表通过节点之间的指针链接来存储数据。

2. 插入和删除操作的效率：顺序表的插入和删除操作需要移动元素，因为需要保持数据的连续性，所以时间复杂度为O(n)。而链表的插入和删除操作仅需要修改指针的指向，时间复杂度为O(1)。

3. 访问元素的效率：顺序表可以通过索引快速访问元素，时间复杂度为O(1)。而链表需要通过遍历的方式来查找特定位置的元素，时间复杂度为O(n)。

4. 空间使用：顺序表在创建时需要指定容量，在操作过程中不会动态改变大小。而链表可以根据需要动态添加或删除节点，空间使用更灵活。

5. 内存分配：顺序表在创建时就分配一块连续的内存空间，而链表可以动态分配每个节点的内存空间。

根据实际需求，选择适合的数据结构可以提高程序的效率。如果需要频繁执行插入和删除操作，而不关注元素的随机访问效率，链表可能更适合。而如果需要频繁的随机访问元素，或者预先知道数据的大小，顺序表可能更合适。