目录
前言
在学习数据结构过程中，我们经常要用到顺序表和链表。顺序表的优点是可以随机访问，缺点是增删效率低。链表恰好弥补了顺序表的缺点，但是不能随机访问，而且代码比较麻烦。因为在进行插入删除操作时，我们必须考虑链表为空和不为空两种情况。除此之外，想要访问当前节点的上一个节点，就必须把链表再遍历一遍，降低了运行速度。那么，有没有有一种可能，链表也能非常方便地插入、删除、找前后节点呢？这就是本文要为大家介绍的，带头双向循环链表。
一、结构介绍
我们从单链表开始探索：
单链表的节点由两部分组成，即存储的数据、指向下一个节点的指针。
用代码定义如下：
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;这种结构是单向的，不能从后往前找，于是可以想到，在结构体中再加上一个指针，用来指向前一个节点，这样我们的链表就变成了双向链表。
代码定义如下：
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
struct SListNode* prev;
}SListNode;通过指针prev即可倒回去找前面的节点。这样能在一定程度上减少麻烦。
当然，这种情况下，进行插入操作时，还需要顾及链表是否为空的情况。两种情况操作不同，会增加代码量。因此，我们可以增加一个头节点head，不存储数据，只是占一个位置，我们称之为哨兵位。这样，即使链表为空，也有一个节点，可以进行访问next指针的操作。
以下是链表创建过程：
ListNode* BuyLTNode(LTDataType x)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
ListNode* ListCreate()
{
ListNode* L = BuyLTNode(-1);
L->next = NULL;
L->prev = NULL;
return L;
}简单解释：创建一个新的节点，让其中存储-1（随便什么都行），prev和next指针置为空，这个节点是头节点，不存储实际数据，但是在插入时能简化操作。
头插方便了，但是如果要在尾部插入呢？你需要先创建一个指针，遍历链表，找到链表尾部，然后再插入，好麻烦那！别急，我们的带头双向链表继续升级，带头双向循环链表，就可以解决这个问题。
以下是链表创建过程：
ListNode* BuyLTNode(LTDataType x)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
ListNode* ListCreate()
{
ListNode* L = BuyLTNode(-1);
L->next = L;
L->prev = L;
return L;
}最初创建头节点时，头节点两个指针可以自己指向自己。
二、增删查改的实现
1.在某一位置前插入数据
void ListInsert(ListNode* pos, LTDataType x)
{
assert(pos);
ListNode* newnode = BuyLTNode(x);
newnode->prev = pos->prev;
pos->prev->next = newnode;
newnode->next = pos;
pos->prev = newnode;
}在这里，不管是在哪里插入，都可以用这段代码，因为任何节点之间的结构都是一样的。可以配合另一个寻找节点的函数使用，先找到想要的节点，再在前面插入。
2.头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
assert(pHead);
ListInsert(pHead->next, x);
}正因这种结构良好的兼容性，插入代码可以直接用来为头插函数服务。而在有头节点的情况下，只需通过头节点找next即可找到插入位置。
3.尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
assert(pHead);
ListInsert(pHead, x);
}插入代码也可以直接用来为尾插函数服务。而尾插是在链表最后插入，但是对于循环链表，链表的头即是尾，尾即是头，只需传头节点指针，头节点的前一个位置，就是链表尾。是不是巨方便？
4.删除某一位置的节点
void ListErase(ListNode* pos)
{
assert(pos);
ListNode* prev = pos->prev;
ListNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}这里由于要删除节点，需要断开前后联系，可以先创建临时指针表示前后的节点，方便后面操作。
不管是哪里删除，都可以用这段代码。可以配合查找函数使用。
5.头删
void ListPopFront(ListNode* pHead)
{
assert(pHead);
ListErase(pHead->next);
}有了插入函数，我们可以直接在头删函数中使用。注意头删可不是删除头节点，头节点只是占个位置，招你惹你了？删的是头节点的下一个位置，这才是第一个元素。
6.尾删
void ListPopBack(ListNode* pHead)
{
assert(pHead);
ListErase(pHead->prev);
}插入函数在尾删也是可以直接用滴！想找尾？头节点的前一个就是！！！是不是巨方便？
7.查找
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;
}当然了，不管是是顺序表还是链表，要查找，他都得遍历。从头开始，找到那个存x的结点，返回它的地址就行。
8.打印
void ListPrint(ListNode* pHead)
{
assert(pHead);
ListNode* cur = pHead->next;
while (cur != pHead)
{
printf("%d<==>", cur->data);
cur = cur->next;
}
printf("\n");
}你别说，没这个函数其实也行，但是不好测试。这个函数主要是为了能在测试时把链表显示出来，让你知道，你成功辣！
9.销毁
void ListDestory(ListNode* pHead)
{
assert(pHead);
ListNode* cur = pHead->next;
while (cur != pHead)
{
ListNode* prev = cur;
cur = cur->next;
free(prev);
}
free(pHead);
}虽然退出程序操作系统会自动回收空间，但是如果这段代码用来做其他项目的接口，可能要运行很长时间，内存泄漏可是不好的。用完要销毁。每个节点都要free掉哦。
三、完整项目代码
1.头文件(List.h)
#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);2.函数文件(List.c)
#include "List.h"
ListNode* BuyLTNode(LTDataType x)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
ListNode* ListCreate()
{
ListNode* L = BuyLTNode(-1);
L->next = L;
L->prev = L;
return L;
}
void ListDestory(ListNode* pHead)
{
assert(pHead);
ListNode* cur = pHead->next;
while (cur != pHead)
{
ListNode* prev = cur;
cur = cur->next;
free(prev);
}
free(pHead);
}
void ListPrint(ListNode* pHead)
{
assert(pHead);
ListNode* cur = pHead->next;
while (cur != pHead)
{
printf("%d<==>", cur->data);
cur = cur->next;
}
printf("\n");
}
void ListPushBack(ListNode* pHead, LTDataType x)
{
ListInsert(pHead, x);
}
void ListPopBack(ListNode* pHead)
{
assert(pHead);
ListErase(pHead->prev);
}
void ListPushFront(ListNode* pHead, LTDataType x)
{
assert(pHead);
ListInsert(pHead->next, x);
}
void ListInsert(ListNode* pos, LTDataType x)
{
assert(pos);
ListNode* newnode = BuyLTNode(x);
newnode->prev = pos->prev;
pos->prev->next = newnode;
newnode->next = pos;
pos->prev = newnode;
}
void ListPopFront(ListNode* pHead)
{
assert(pHead);
ListErase(pHead->next);
}
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 ListErase(ListNode* pos)
{
assert(pos);
ListNode* prev = pos->prev;
ListNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}3.主函数测试文件(test.c)
#include"List.h"
int main()
{
ListNode* pHead = NULL;
pHead = ListCreate();
printf("尾插1、2、3、4\n");
ListPushBack(pHead, 1);
ListPushBack(pHead, 2);
ListPushBack(pHead, 3);
ListPushBack(pHead, 4);
ListPrint(pHead);
printf("尾删一次\n");
ListPopBack(pHead);
ListPrint(pHead);
printf("头插5、6、7、8\n");
ListPushFront(pHead, 5);
ListPushFront(pHead, 6);
ListPushFront(pHead, 7);
ListPushFront(pHead, 8);
ListPrint(pHead);
printf("头删一次\n");
ListPopFront(pHead);
ListPrint(pHead);
printf("删除元素为1的节点\n");
ListErase(ListFind(pHead, 1));
ListPrint(pHead);
printf("销毁链表\n");
ListDestory(pHead);
pHead = NULL;
return 0;
}记得最后将pHead制空，因为函数内部不能改变原指针，需要在外部制空，这样就永远找不到那份空间了。
这个测试代码可以很好地测试一下你写的函数是否可以运行起来（不包括函数的提醒报错功能，因为运行不起来不容易看结果）。那么，我们测试运行以下，结果如下：
看来我们的代码非常成功。带头双向循环链表真是太好用辣！
672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
