单向链表存在一些缺陷：1.无法从后往前遍历。2.无法找到节点的前一个节点。3.插入和删除数据的时间复杂度为O（N）。这对这些缺陷，双向循环链表提供了很好的解决办法，双向循环链表的插入和删除时间复杂度为O（1）。
文章目录
带头双向循环链表
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。
这个链表的结构如下：箭头的指向就代表着节点中的指针存储目标节点的地址
一般情况下，头结点head也被叫做哨兵节点，这个节点的数据域并不会被使用，因此存储什么样的数据都不影响。头结点指向的下一个节点才是我们使用的节点。
由于头结点并不会被删除，也就是说我们的指针指向的起始位置并不会改变，因此我们不用像单链表一样在头删时传入二级指针。
带头双向循环链表代码实现
- 定义双向循环链表
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* next;//用于指向下一个节点
struct ListNode* prev;//用于指向上一个节点
LTDataType data;//存储数据
}ListNode;//取别名
- 创建新的节点
//创建新节点
ListNode* BuyListNode(LTDataType x)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
- 初始化链表
//初始化
ListNode* ListInit()
{
//由于初始化时为空指针，因此需要创建创建一个头结点，头结点的值不需要在意
ListNode* phead = BuyListNode(0);
phead->next = phead;//指向下一个节点的指针指向自身
phead->prev = phead;//指向上一个节点的指针指向自身
return phead;
}
- 创建链表结构指针并初始化
ListNode* plist = NULL;
plist=ListInit();
由于一开始创建的结构体指针plist是空指针，因此我们需要在初始化时创建一个哨兵位头结点，使plist指向这个头节点。在后续的使用中，plist始终是指向这个头结点，并不会被修改，因此不需要传入二级指针。
- 打印节点的数据
// 打印
void ListPrint(ListNode* phead)
{
assert(phead);
ListNode* cur = phead->next;//cur指向第一个节点
while (cur!=phead)
{
printf("%d ", cur->data);
cur = cur->next;//cur指向下一个节点
}
printf("\n");
}
- 在pos位置前插入数据
//pos位置之前插入x
void ListInsert(ListNode* pos, LTDataType x)
{
assert(pos);
ListNode* prev = pos->prev;//找到pos前一个节点
ListNode* newnode = BuyListNode(x);//创建新的节点
prev->next = newnode;//pos前一个节点指向新的节点
newnode->prev = prev;//新节点指向前一个节点
newnode->next = pos;//新节点指向pos节点
pos->prev = newnode;//pos节点指向新的节点
}
- 删除pos位置的节点
//删除pos位置的值
void ListErase(ListNode* pos)
{
ListNode* prev = pos->prev;//找到pos前一个节点
prev->next = pos->next;//pos前一个节点指向pos后一个节点
pos->next->prev = prev;//pos后一个节点指向pos前一个节点
free(pos);
pos = NULL;
}
- 头插
//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
//方法1
/*assert(phead);*/
如果是一个节点的情况，也没问题
//ListNode* first = phead->next;//第一个节点
//ListNode* newnode = BuyListNode(x);//创建新的节点
//phead->next=newnode;//哨兵节点指向新的节点
//newnode->prev = phead;//新的节点指向哨兵节点
//newnode->next = first;//新的节点指向第一个节点
//first->prev = newnode;//第一个节点指向新的节点
//方法2
assert(phead);
ListInsert(phead->next, x);
}
头插就相当于在头结点head后面的第一个节点前插入，因此可以直接调用任意位置插入的函数。
- 尾插
//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
//方法1
/*assert(phead);*/
如果是一个节点的情况，也没问题
//ListNode* tail = phead->prev;//最后一个节点
//ListNode* newnode = BuyListNode(x);//创建新的节点
//tail->next = newnode;//最后一个节点指向新的节点
//newnode->next = phead;//新的节点指向哨兵节点
//newnode->prev = tail;//新的节点指向最后一个节点
//phead->prev = newnode;//哨兵节点指向新的节点
//方法2
assert(phead);
ListInsert(phead, x);
}
尾插就相当于在头结点的前面插入，因为头结点的上一个节点就是尾结点。
- 头删
//头删
void ListPopFront(ListNode* phead)
{
//方法1
//assert(phead);
//assert(phead->next!=phead);//如果只剩哨兵节点，直接报错，因为哨兵结点不能删除
//ListNode* first = phead->next;//第一个节点
//ListNode* second = first->next;//第二个节点
//phead->next = second;//哨兵节点指向第二个节点
//second->prev = phead;//第二个节点指向哨兵节点
//free(first);
//first = NULL;
//方法2
ListErase(phead->next);
}
头删就是删除头结点的下一个节点
- 尾删
//尾删
void ListPopBack(ListNode* phead)
{
//方法1
//assert(phead);
//assert(phead->next != phead);//如果只剩哨兵节点，直接报错，因为哨兵结点不能删除
//ListNode* tail = phead->prev;//最后一个节点
//ListNode* prev = tail->prev;//倒数第二个节点
//prev->next = phead;//倒数第二个节点指向哨兵节点
//phead->prev = prev;//哨兵节点指向倒数第二个节点
//方法2
ListErase(phead->prev);
}
尾删相当于删除头结点的上一个节点
- 查找数据，返回节点的指针
//查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
assert(phead);
ListNode* cur = phead->next;//cur指向第一个节点
while (cur != phead)//如果cur为哨兵节点，则说明找了一圈没找到
{
if (cur->data == x)
{
return cur;//找到以后返回指针
}
cur = cur->next;//cur指向下一个节点
}
return NULL;
}
- 销毁链表
//销毁
void ListDestory(ListNode* phead)
{
assert(phead);
ListNode* cur = phead->next;//cur是第一个节点
while (cur != phead)
{
//next指向cur下一个节点，因为cur释放以后就没法通过cur找到下一个节点了
//因此需要next先保存一下
ListNode* next = cur->next;
free(cur);
cur = next;//cur指向cur下一个节点
}
free(phead);//释放掉哨兵位节点
phead = NULL;
}
通过上面的代码不难发现，头插尾插头删尾删的代码都可以复用在pos位置插入删除的代码。并且由于是循环的结构，在实际的插入和删除数据时，并不需要考虑是否只有一个头结点的情况。
因此双向循环链表虽然结构上复杂，但代码实现上却简单不少。