带头双向循环链表的实现

一、基本单元

链表其实就是通过指针，在具有相同类型的数据之间两两建立联系。因此，我们需要一个基本单元，来实现链表的链接；

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

链表中每个数据的类型我们定义为LTDateType，可以是整型，也可以是其他，若需要改动，可以直接改动tyepdef而将影响降低到最小。

链表是通过指针来建立联系的，所以我们可以定义两个指针，一个next指针指向下一个数据，另一个prev指针指向上一个数据。

二、增删查的实现

1、创建链表

我们知道链表是由一个个基本单元连接起来的，当我们进行增删查改时，也是对一个个基本单元的改动，因此，我们需要一个函数来帮我们创建一个基本单元——结点。

ListNode* BuyListNode(LTDataType x)
{
	ListNode* temp = (ListNode*)malloc(sizeof(ListNode));
	if (temp == NULL)
	{
		perror("Malloc Fail");
		return NULL;
	}
	temp->data = x;
	temp->next = NULL;
	temp->prev = NULL;
	return temp;
}

这个函数会使用malloc函数开辟一块结点的空间并且返回它的地址；如果开辟失败也给出了相应的报错。

接下来我们使用它创建一个链表的头结点；

ListNode* ListCreate()
{
	ListNode* pHead = BuyListNode(0);
	if (pHead == NULL)
		exit(-1);
	pHead->next = pHead;
	pHead->prev = pHead;
	return pHead;
}

因为我们创建的是双向带头循环链表，所以返回的头结点的两个指针，都需要指向它自己；

2、增添数据

为了使程序更通用，这里我直接讲在任意位置的前面（后面也可以）插入/增加某个数据；

当我们知道某个数据的位置时——pos，例如我们需要在1和3之间插入2时：（也就是知道3的位置）

 可以先将2的next指向3，2的prev指向1（这个可以通过3的prev得知）。

 这时可以通过3的prev找到1，让1的next指向2；

 最终我们将3的prev指向2就能完成插入；

 代码实现如下：

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* temp = BuyListNode(x);
	if (temp == NULL)
		return;
	temp->next = pos;
	temp->prev = pos->prev;
	pos->prev->next = temp;
	pos->prev = temp;
}

 当使用头插和尾插时，我们直接将pos位置改掉就好；

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead->next, x);
}

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead, x);
}

3、删除数据 

同样的，我们先将删除任意位置的数据；

在删除的时候要注意，如果表中没有数据，也就是只剩下一个头的时候，就不要再删了，所以我们需要判断一下；

现在我们要删掉2这个位置的数据，并且已经知道其地址。

将其删掉一定不要忘记free，因此我们先创建一个变量temp将2的地址存起来。

 然后我们通过2找到1，让1的next指向2的后面，也就是3；

再通过2找到3，让3的prev指向1，

 

这样，1和3就完成了连接，然后将2 free掉就可以啦； 

代码如下：

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	if (pos->next == pos)
		return;
	ListNode* temp = pos;
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(temp);
}

同样的，头删和尾删的代码如下：

// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->next);
}

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->prev);
}

3、查找、打印、销毁

这三个都比较简单，都是遍历一遍链表就可以，只要注意一下循环结束的条件即可

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

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

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->next;
	printf("Head <==> ");
	while (pHead != cur)
	{
		printf("%d <==> ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* temp = pHead->next;
	while (pHead->next != pHead)
	{
		temp = temp->next;
		free(pHead->next);
		pHead->next = temp;
	}
	free(pHead);
}

三、头文件与总结

总结一下，双向带头循环链表虽然看起来比较难，但使用起来及其方便，自己动手敲一敲，很快就可以掌握。以下是头文件：

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);