目录
前言
双链表节点定义
接口函数实现
初始化函数
创建节点
打印双链表
尾插节点
尾删节点
头插节点
头删节点
指定位置前插入
删除指定位置节点
改写插入删除
判断链表是否为空
计算链表长度
销毁链表
双链表完整代码
浅谈链表及顺序表
前言
前面我们已经实现了无头单向非循环链表，现在我们来实现带头双向循环链表。
双链表节点定义
//双链表节点定义
typedef int LDataType;
typedef struct ListNode
{
struct ListNode* prev;
struct ListNode* next;
LDataType data;
}LNode;与单链表不同的是，在实现双链表时，我们需要创建一个初始化函数。双链表的初始化需要一个头节点，并且这个头节点的prev指针和next指针需要指向自身。
接口函数实现
初始化函数
初始化函数创建了一个头节点（哨兵卫），这个哨兵卫不储存值，并且让它的prev、next指向自身。这样就形成了一个闭环。
//初始化双链表
LNode* LInit()
{
LNode* newnode = (LNode*)malloc(sizeof(LNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
//prev与next均指向自身
newnode->next = newnode;
newnode->prev = newnode;
return newnode;
}
与单链表的实现类似，我们同样也实现两个函数用来检测和辅助其他函数的实现。
创建节点
//创建节点、
LNode* BuyListNode(LDataType x)
{
LNode* newnode = (LNode*)malloc(sizeof(LNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->data = x;
//创建后的节点prev与next均指向NULL
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}新创建的节点的prev与next指针我们让他们指向NULL就可以了，因为后面我们还会处理它的链接关系，所以指向空指针就可以了。
打印双链表
//打印双链表
void LPrint(LNode* phead)
{
assert(phead);
LNode* cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}PS：
打印链表信息之所以从phead->next开始是因为我们的phead并没有存值，链表的节点信息是从phead->next开始的。
尾插节点
//尾插节点
void LPushBack(LNode* phead,LDataType x)
{
//防止传入空指针
assert(phead);
//先将x存入创建的节点中
LNode* newnode = BuyListNode(x);
//链表最后一个节点就是phead的prev指针
LNode* tail = phead->prev;
//将newnode节点链接到链表中
tail->next = newnode;
phead->prev = newnode;
newnode->next = phead;
newnode->prev = tail;
}
可能会有人会问，为什么双链表在尾插的时候传的参数是一级指针啊？单链表在尾插节点的的时候传的就是二级指针。那是因为我们现在实现的双链表具有头节点（哨兵卫），正是因为有了它，我们就不用传二级指针了。为什么了，前面我们讲过，单链表之所以传入的是二级指针。那是因为在特殊情况下我们的第一个节点会变成空指针。有哨兵卫后就不同了，假如我们现在双链表中只存在一个节点，我们将它删除，只需要将phead的prev与next均指向自身就可以了，而如果没有哨兵卫，我们就要将phead置成空指针，这样传入的参数就改变了，那么就需要传二级指针。
其实就一点，如果链表有哨兵卫的话就直接传入一级指针就可以了。
尾删节点
//尾删节点
void LPopBack(LNode* phead)
{
assert(phead);
//防止传入的链表是一个空链表
assert(phead->prev != phead);
LNode* tail = phead->prev;
LNode* tailPrev = tail->prev;
//每个节点都是动态开辟出来的，记得释放
free(tail);
phead->prev = tailPrev;
tailPrev->next = phead;
}
头插节点
//头插节点
void LPushFront(LNode* phead, LDataType x)
{
assert(phead);
LNode* newnode = BuyListNode(x);
LNode* first = phead->next;
phead->next = newnode;
first->prev = newnode;
newnode->prev = phead;
newnode->next = first;
}
头删节点
//头删节点
void LPopFront(LNode* phead)
{
assert(phead);
//防止链表为空
assert(phead->next != phead);
LNode* first = phead->next;
LNode* newfirst = first->next;
free(first);
phead->next = newfirst;
newfirst->prev = phead;
}
指定位置前插入
//指定位置前插入
void LInsert(LNode* pos, LDataType x)
{
assert(pos);
LNode* newnode = BuyListNode(x);
LNode* posPrev = pos->prev;
newnode->next = pos;
pos->prev = newnode;
posPrev->next = newnode;
newnode->prev = posPrev;
}
删除指定位置节点
//删除指定位置节点
void LErase(LNode* pos)
{
assert(pos);
LNode* posNext = pos->next;
LNode* posPrev = pos->prev;
free(pos);
posPrev->next = posNext;
posNext->prev = posPrev;
}
改写插入删除
有了删除指定位置节点函数和指定位置前插入函数，我们就可以改写尾插尾删、头插头删函数。
//尾插节点
void LPushFront(LNode* phead, LDataType x)
{
LInsert(phead, x);
}
//尾删节点
void LPopBack(LNode* phead)
{
LErase(phead->prev);
}
//头插节点
void LPushFront(LNode* phead, LDataType x)
{
LInsert(phead->next, x);
}
//头删节点
void LPopFront(LNode* phead)
{
LErase(phead->next);
}判断链表是否为空
//判断链表是否为空
bool LIsEmpty(LNode* phead)
{
assert(phead);
return phead == phead->next;
}计算链表长度
//计算链表长度
int LSize(LNode* phead)
{
int count = 0;
LNode* cur = phead->next;
while (cur != phead)
{
count++;
cur = cur->next;
}
return count;
}销毁链表
//销毁链表
void LDestroy(LNode* phead)
{
assert(phead);
LNode* cur = phead->next;
//将每个节点都释放
while (cur != phead)
{
LNode* next = cur->next;
free(cur);
cur = next;
}
//自己手动将phead置为空指针
free(phead);
}双链表完整代码
List.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
#include <stdbool.h>
typedef int LDataType;
typedef struct ListNode
{
struct ListNode* prev;
struct ListNode* next;
LDataType data;
}LNode;
//初始化双链表
LNode* LInit();
//打印双链表
void LPrint(LNode* phead);
//创建一个节点
LNode* BuyListNode(LDataType x);
//尾插尾删
void LPushBack(LNode* phead, LDataType x);
void LPopBack(LNode* phead);
//头插头删
void LPushFront(LNode* phead, LDataType x);
void LPopFront(LNode* phead);
//在指定位置前插入，删除指定位置
void LErase(LNode* pos);
void LInsert(LNode* pos, LDataType x);
//销毁链表
void LDestroy(LNode* phead);
//判断链表是否为空
bool LIsEmpty(LNode* phead);
//计算链表节点个数
size_t LSize(LNode* phead);List.c
#include "List.h"
LNode* LInit()
{
LNode* newnode = (LNode*)malloc(sizeof(LNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->next = newnode;
newnode->prev = newnode;
return newnode;
}
LNode* BuyListNode(LDataType x)
{
LNode* newnode = (LNode*)malloc(sizeof(LNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
void LPushBack(LNode* phead,LDataType x)
{
assert(phead);
LNode* newnode = BuyListNode(x);
LNode* tail = phead->prev;
tail->next = newnode;
phead->prev = newnode;
newnode->next = phead;
newnode->prev = tail;
//LInsert(phead, x);
}
void LPopBack(LNode* phead)
{
assert(phead);
assert(phead->prev != phead);
LNode* tail = phead->prev;
LNode* tailPrev = tail->prev;
free(tail);
phead->prev = tailPrev;
tailPrev->next = phead;
//LErase(phead->prev);
}
void LPrint(LNode* phead)
{
assert(phead);
LNode* cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}
void LPushFront(LNode* phead, LDataType x)
{
assert(phead);
LNode* newnode = BuyListNode(x);
LNode* first = phead->next;
phead->next = newnode;
first->prev = newnode;
newnode->prev = phead;
newnode->next = first;
//LInsert(phead->next, x);
}
void LPopFront(LNode* phead)
{
//assert(phead);
//assert(phead->next != phead);
//LNode* first = phead->next;
//LNode* newfirst = first->next;
//free(first);
//phead->next = newfirst;
//newfirst->prev = phead;
LErase(phead->next);
}
LNode* LFind(LNode* phead, LDataType x)
{
assert(phead);
LNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
void LErase(LNode* pos)
{
assert(pos);
LNode* posNext = pos->next;
LNode* posPrev = pos->prev;
free(pos);
posPrev->next = posNext;
posNext->prev = posPrev;
}
void LInsert(LNode* pos, LDataType x)
{
assert(pos);
LNode* newnode = BuyListNode(x);
LNode* posPrev = pos->prev;
newnode->next = pos;
pos->prev = newnode;
posPrev->next = newnode;
newnode->prev = posPrev;
}
void LDestroy(LNode* phead)
{
assert(phead);
LNode* cur = phead->next;
while (cur != phead)
{
LNode* next = cur->next;
free(cur);
cur = next;
}
//自己手动置为空指针
free(phead);
}
bool LIsEmpty(LNode* phead)
{
assert(phead);
return phead == phead->next;
}
int LSize(LNode* phead)
{
int count = 0;
LNode* cur = phead->next;
while (cur != phead)
{
count++;
cur = cur->next;
}
return count;
}浅谈链表及顺序表
链表和顺序表都作为线性表，他们之间有何异同呢？如以下表格：
| 不同点 | 顺序表 | 链表 |
| 存储空间上 | 物理上一定连续 | 逻辑上连续，物理空间上不一定连续 |
| 随机访问 | 支持 O(1) | 不支持 O(N) |
| 任意位置插入和删除元素 | 可能需要搬移元素，效率低；O(N) | 只需修改指针指向 |
| 插入 | 动态顺序表，空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |
| 缓存利用率 | 高 | 低 |
以上就是双链表实现的全部内容了，希望能够帮助到大家。如果有不对的地方请各位大佬在评论区指正（鞠躬）。
