目录
前言
在前面的单链表专题中，我们了解到了链表的一共有八种结构，但是最常用的链表结构还是单链表中的不带头单向不循环链表和双链表中的带头双向循环链表。
带头双向循环链表
每个结点有三个内容：
1、保存的数据data
2、保存下一个结点的地址next指针
3、保存前一个结点的地址的prev指针
双向链表的结构定义
cpp
//定义双向链表结点的结构
typedef int LTDataType;
struct ListNode {
LTDataType data;//保存的数据
struct ListNode* next; //指向下一个结点的指针next
struct ListNode* prev; //指向上一个结点的指针prev
};
typedef struct ListNode LTNode;链表的初始化
在这里我们进行插入和删除等操作时函数传参时是一个一级指针而非二级，这是因为我们的带头双向不循环链表在开始时便已经有了一个哨兵位，我们只需要使用指向该哨兵位的指针就可以实现对其它有效结点的操作，而之前的不带头单向不循环链表中没有哨兵位就需要使用一个二级指针指向存放链表第一个有效结点地址的一级指针，然后通过操纵该一级指针指向的有效结点中的next指针实现插入和删除操作（带头的单向不循环链表也可以不使用二级指针）
带头的链表传参时使用的是二级指针，不带头的链表传参时使用的是一级指针
至于使用一级指针后到底简不简单请往下看：
cpp
//test.c文件：
#include "List.h"
void ListTest()
{
LTNode* plist = LTInit();
}
int main()
{
ListTest();
return 0;
}
//SList.c文件：
#include "List.h"
LTNode* LTInit()
{
//用phead指针指向为哨兵位申请的内存空间
LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
if (phead == NULL)
{
perror("malloc error");
return;
}
//哨兵位中不存储有效数据，我们这里给它存一个-1表示无效数据就行
phead->data = -1;
//对哨兵位的前驱和后继指针实现一个循环效果
phead->next = phead->prev = phead;
//返回新创建的哨兵位
return phead;
}
（这里的应该是phead忘记改了┭┮﹏┭┮）
通过调试可以发现两种方法都实现了循环效果
尾插
cpp
//申请新结点node，并为其存储数据x
LTNode* ListByNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
node->data = x;
node->next = node->prev = NULL;
return node;
}
//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
//保证哨兵位不为空
assert(phead);
LTNode* node = ListByNode(x);
//先处理新节点node的前驱和后继指针
node->prev = phead->prev;
node->next = phead;
//再处理哨兵位的上一个结点的的后继指针（相当于图里的d3）和哨兵位的前驱指针
phead->prev->next = node;
phead->prev = node;
}
（关于成功演示，这里只看一个结果，具体代码会一起放在test.c文件中）
头插
cpp
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* node = ListByNode(x);
//先处理新节点node的前驱和后继指针
node->prev = phead;
node->next = phead->next;
//再处理phead->prev(之前的尾结点)和phead
phead->next->prev = node;
phead->next = node;
}
尾删
cpp
//尾删
void LTPopBack(LTNode* phead)
{
assert(phead);
//除了保证有哨兵位之外，还需要保证链表必须要有有效结点，只有哨兵位时不能执行删除操作
assert(phead->next != phead);
//这里的del就相当于d2
LTNode* del = phead->prev;
//先处理del的prev结点
del->prev->next = phead;
//处理phead
phead->prev = del->prev;
free(del);
del = NULL;
}
字体懒得再写一遍改成蓝色的了，将就着看吧┭┮﹏┭┮
头删
cpp
//头删
void LTPopFront(LTNode* phead)
{
assert(phead && phead->next != phead);
LTNode* del = phead->next;
//phead del->next
del->next->prev = phead;
phead->next = del->next;
free(del);
del = NULL;
}
结点的查找
cpp
//查找结点
LTNode* LTFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* cur = phead->next;
//遍历链表
while (cur != phead)//不能等于哨兵位
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}在指定位置后插入
cpp
//在pos位置后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* node = ListByNode(x);
//node的prev和next
node->next = pos->next;
node->prev = pos;
//pos的next职责和pos->next的prev
pos->next = node;
node->next->prev = node;
}
删除指定位置结点
cpp
//删除指定位置
void LTErase(LTNode* pos)
{
assert(pos);
//pos->prev:next pos pos->next:prev
pos->next->prev = pos->prev;
pos->prev->next = pos->next;
free(pos);
pos = NULL;
}
链表的销毁
cpp
//销毁链表
void LTDestory(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
//除了循环之后，哨兵位还未释放
free(phead);
phead = NULL;
}接下来是我们在链表销毁时开启的监视窗口，虽然可能有点长但是还请看完：
程序结束后：
我们会发现即使程序结束后，phea的值已经被置空但是plist的值并未被置空......
这是因为我们用于接收plist的是一个一级指针phead，对于一级指针phead的改变并不会影响plist（前面单链表中我们了解到对二级指针一次解引用后才能修改plist） ,所以当我们传递一级指针时需要手动在test.c文件中的销毁链表函数后添加一个free(plist)
最终结果：
SList.h文件：
cpp
#include "List.h"
//不需要传入参数，调用该方法后我们返回一个头结点
LTNode* LTInit()
{
LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
if (phead == NULL)
{
perror("malloc error");
return;
}
phead->data = -1;
phead->next = phead->prev = phead;
//返回新创建的头结点
return phead;
}
//申请新结点node，并为其存储数据x
LTNode* ListByNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
node->data = x;
node->next = node->prev = NULL;
return node;
}
//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
assert(phead);
LTNode* node = ListByNode(x);
//先处理新节点node的前驱和后继指针
node->prev = phead->prev;
node->next = phead;
//再处理phead->prev(之前的尾结点)和phead
phead->prev->next = node;
phead->prev = node;
}
//打印
void LTPrint(LTNode* phead)
{
LTNode* cur = phead->next;
while (cur != phead)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("\n");
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* node = ListByNode(x);
//先处理新节点node的前驱和后继指针
node->prev = phead;
node->next = phead->next;
//再处理phead->prev(之前的尾结点)和phead
phead->next->prev = node;
phead->next = node;
}
//尾删
void LTPopBack(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTNode* del = phead->prev;
//先处理del的prev结点
del->prev->next = phead;
//处理phead
phead->prev = del->prev;
free(del);
del = NULL;
}
//头删
void LTPopFront(LTNode* phead)
{
assert(phead && phead->next != phead);
LTNode* del = phead->next;
//phead del->next
del->next->prev = phead;
phead->next = del->next;
free(del);
del = NULL;
}
//在指定位置后插入
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* node = ListByNode(x);
//node的prev和next
node->next = pos->next;
node->prev = pos;
//pos的next职责和pos->next的prev
pos->next = node;
node->next->prev = node;
}
//删除指定位置
void LTErase(LTNode* pos)
{
assert(pos);
//pos->prev:next pos pos->next:prev
pos->next->prev = pos->prev;
pos->prev->next = pos->next;
free(pos);
pos = NULL;
}
//查找结点
LTNode* LTFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
//销毁链表
void LTDestory(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
//除了循环之后，哨兵位还未释放
free(phead);
phead = NULL;
}SList.c文件：
cpp
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//定义双向链表结点的结构
typedef int LTDataType;
struct ListNode {
LTDataType data;//保存的数据
struct ListNode* next;
struct ListNode* prev;
};
typedef struct ListNode LTNode;
//链表的初始化
LTNode* LTInit(); //不需要传入参数，调用该方法后直接返回一个头结点
//因为这是带头双向循环链表，在初始状态时，双向链表为空（只有一个哨兵位），哨兵位结点是不能被操作，
//即哨兵位不能被改变的，所以我们就不需要像之前的不带头单向不循环链表一样需要修改头结点
//哨兵位的下一个结点是链表的第一个结点（头结点），而哨兵位下一个结点是链表的最后一个结点（尾结点）
//我们在这里规定：称后续的链表的第一个有效结点为链表的头结点，链表的最后一个结点叫做尾结点，原来的头结点现在我们称之为哨兵位
//尾部插入操作（往哨兵位的前一个位置插入也叫尾插）
void LTPushBack(LTNode* phead, LTDataType x);
//打印
void LTPrint(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);
//在指定位置后插入
void LTInsert(LTNode* pos, LTDataType x);
//删除指定位置
void LTErase(LTNode* pos);
//查找结点
LTNode* LTFind(LTNode* phead, LTDataType x);
//销毁链表
void LTDestory(LTNode* phead); test.c文件：
cpp
#include "List.h"
void ListTest()
{
LTNode* plist = LTInit();
LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPushBack(plist, 5);//1->2->3->4->5->
//LTPrint(plist);
//LTPushFront(plist, 6);
//LTPushFront(plist, 7);
//LTPushFront(plist, 8);//8->7->6->1->2->3->4->5->
//LTPrint(plist);
/*LTPopBack(plist);
LTPopBack(plist);
LTPopBack(plist);
LTPrint(plist);*/
//LTPopFront(plist);
//LTPopFront(plist);
//LTPopFront(plist);
//LTPopFront(plist);
//LTPopFront(plist);
//LTPrint(plist);
//LTNode* find = LTFind(plist, 2);
///*LTInsert(find, 11);*/
LTErase(find);
LTPrint(plist);
LTDestory(plist);
传递一级指针时需要手动将plist置为空
//plist = NULL;
}
int main()
{
ListTest();
return 0;
}顺序表和链表的优缺点分析
|-------------|------------------|----------------|
| 不同点 | 顺序表 | 链表 |
| 存储空间上 | 物理上一定连续 | 逻辑上连续但物理上不一定连续 |
| 随机访问 | 支持O（1） | 不支持：O（N） |
| 任意位置插入或删除元素 | 可能需要移动元素，效率低O（N） | 只需修改指针方向 |
| 插入 | 动态顺序表，空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |
emm，可能有些地方写的还是不太好但由于时间原因还没来得及更改，这两天抽时间再看看改一下┭┮﹏┭┮
~over~