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

关于链表基本知识，和单链表的实现请看上一篇博客。

本篇文章内容是带头双向循环链表的实现，它和单链表（不带头单向不循环）相比，带头双向循环链表的逻辑更加复杂了，但是当我们实现的时候就会发现非常的舒服，不需要向单链表那样需要考虑的那么多，实现会相对容易。
本次文章的内容还是分为三部分：
1️⃣List.c 链表的功能实现。
2️⃣List.h 部分头文件，结构体的创建，函数的声明。
3️⃣test.c 链表功能的测试。

一、List.c

1、创建新结点

这里依旧采用的是动态开辟内存，之后要进行一下是否开辟成功的判断。
还要将结构体当中的数据先进行一次初始化。

LTNode* BuyListNode(LTDataType x)
{//创建新结点
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

2、结点初始化

当初始化的时候因为是带头的所以需要对头进行处理，将指向前驱节点和后驱节点的指针都指向自己。

LTNode*LTInit()
{//初始化
	LTNode* head = BuyListNode(-1);
	head->next = head;
	head->prev = head;
	return head;
}

3、打印数据

打印和单链表的操作是一样的，因为这里不可能为NULL所以需要断言一下。
在这里尽量养成一个好习惯，不要直接使用形式参数，最好在重新创建一个变量来接收形参，
尽管后面不会用到，也要尽量创建新的变量。

void print(LTNode* head)
{//打印
	assert(head);
	LTNode* cur = head->next;
	while (cur!=head)
	{
		printf("%d ",cur->data);
		cur = cur->next;
	}
	printf("\n");
}

下面我们先看任意位置的插入，和删除，当我们把任意位置的插入的删除解决后，会发现头插头删，尾插尾删可以直接调用任意位置的函数直接完成，省了很多的步骤，这也就是为什么别人能完成的那么快的原因。

4、任意位置的前面插入

仍是需要断言一下，带头的原因导致链表不可能为空。将指定位置的两个指针分别指向前后的两个结点，这里也不需要考虑如果就只剩下哨兵位结点怎么办，仔细看一下逻辑都是对的，这也就是带头双向循环链表的优势。

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

5、任意位置的删除（当前位置）

删除完结点时要记得释放空间。

void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

6、尾插

在这里我们可以看到有一部分被注释的代码，那就是如果没有调用任意位置的函数的写法，而没有注释的代码也就是调用之后的代码，可以看到差距还是很大的。

void LTPushBack(LTNode* head, LTDataType x)
{
	assert(head);
	/*LTNode *newnode= BuyListNode(x);
	LTNode* tail = head->prev;
	head->prev = newnode;
	newnode->next = head;
	newnode->prev = tail;
	tail->next = newnode;*/
	LTInsert(head, x);
}

7.尾删

在这里需要注意一下，如果就只剩下一个哨兵位的时候，就不能再继续删除了，所以这里要断言一下。
同样调用的是任意位置函数。

void LTPopBack(LTNode* head)
{
	assert(head);
	assert(head->next != head);
	/*if (head->next == head)
	{
		return;
	}*/
	/*LTNode* tail = head->prev;
	LTNode* next = tail->prev;
	head->prev = next;
	next->next = head;
	free(tail);*/
	LTErase(head->prev);
}

8、头插

void LTPushFront(LTNode* head, LTDataType x)
{
	assert(head);
	/*LTNode* newnode = BuyListNode(x);
	newnode->next = head->next;
	head->next->prev = newnode;
	head->next = newnode;
	newnode->prev = head;*/
	LTInsert(head->next, x);
}

9、头删

在这里需要注意一下，如果就只剩下一个哨兵位的时候，就不能再继续删除了，所以这里要断言一下。
同样调用的是任意位置函数。

void LTPopFront(LTNode* head)
{
	assert(head);
	assert(head->next != head);
	/*LTNode* tail = head->next;
	head->next = tail->next;
	tail->next->prev = head;
	free(tail);*/
	LTErase(head->next);
}

10、查找数据

同样是不可能为NULL所以断言一下，如果找到的话返回当前地址，没找到返回NULL。

LTNode* LTFind(LTNode* head, LTDataType x)
{
	assert(head);
	LTNode* cur = head->next;

	while (cur!=head)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

11、判断链表里除了哨兵位是否有别的结点

当就剩下哨兵位的时候就返回true，不是就是false，用被注释的方法也是可以的，它的可读性更高。

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

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

	return head->next == head;
}

12、判断当前有几个数据

size_t LTSize(LTNode* head)
{
	assert(head);

	size_t size = 0;
	LTNode* cur = head->next;
	while (cur != head)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

13、销毁数据

在这里就只能一个一个的删除，并且释放空间，最后不要忘记哨兵位的释放和置NULL。

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

List.h

包括一些头文件，自定义，结构体的创建，功能函数的声明。

#define _CRT_SECURE_NO_WARNINGS 1

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

//typedef char LTDataType;
//typedef double LTDataType;
typedef int LTDataType;

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

//void LTInit(LTNode** head);
LTNode* BuyListNode(LTDataType x);
LTNode* LTInit();
void print(LTNode* head);
void LTPushBack(LTNode* head, LTDataType x);
void LTPopBack(LTNode* head);

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

LTNode* LTFind(LTNode* head, LTDataType x);

// 在pos之前插入x
void LTInsert(LTNode* pos, LTDataType x);
void LTErase(LTNode* pos);

bool LTEmpty(LTNode* head);
size_t LTSize(LTNode* head);
void LTDestroy(LTNode* head);

test.c

对链表的一些功能进行测试。

#include"SList.h"

int main()
{
	LTNode* head = LTInit();
	//LTInit(&head);
	LTPushBack(head, 1);
	LTPushBack(head, 2);
	LTPushBack(head, 3);
	LTPushBack(head, 4);
	LTPushBack(head, 5);
	print(head);
	//LTPopBack(head);
	//LTPopBack(head);
	//LTPopBack(head);
	//LTPopBack(head);
	print(head);
	LTPushFront(head,0);
	LTPushFront(head,9);
	print(head);
	//LTPopFront(head);
	//LTPopFront(head);
	//LTPopFront(head);
	print(head);
	LTNode*prev=LTFind(head, 1);
	LTInsert(prev,8);
	print(head);
	LTErase(prev);
	print(head);
	bool Judg=LTEmpty(head);
	//printf("%d\n",Judg);
	//size_t a=LTSize(head);
	//printf("%d\n",a);
	LTDestroy(head);
	head = NULL;
	return 0;
}

最后：文章有什么不对的地方或者有什么更好的写法欢迎大家在评论区指出