- 1mac 远程桌面连接_VNC Viewer for Mac(远程桌面软件)
- 2没有学不会的知识，只有不努力的傻子！！！ 学习的过程很痛苦，不学习的日子是苦难！！！ 只要坚持就没有学不会的东西！！！...
- 3图像分割基础及经典网络结构_图像分割网络
- 4解决：Android开发中选择运行设备时无设备可选（huawei终端）_魔点滴定选择设备无设备
- 5基于SSM的图书馆借阅管理系统_云借阅图书管理系统ssm框架
- 6python爬虫爬取的数据与浏览器获取的数据不一样 爬虫爬取到的数据一直不变_爬虫post请求的响应数据与浏览器不一致或少了
- 7.Net Core IFormFile 始终为空的问题
- 8Claude 3 登场：颠覆 GPT-4 的新智能时代到底强在哪里？
- 9宝塔中安装rabbitmq的扩展_bash dapao_amqp.sh install 74
- 10深度学习入门2_深度学习入门2pdf
CSDN小白成长的第五天——链表世界（1），由浅入深，注重每个细节，原创动画，万字博客，详细解说
赞
踩
链表的秘密（1）第一、二章
链表专题目录
第一章 链表和链表的分类
第二章 单链表的实现
第三章 链表OJ题
第四章 双向带头循环链表的实现
第五章 总结和对比链表和顺序表
前情提要：
我们学习完顺序表之后，难免发现其有一些问题，比如：
1.中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到
200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
那么我们自然而然回去思考：如何解决以上问题呢？
下面给出了链表的结构来看看。
一、链表和链表的分类
1.链表
百度百科上的解释：
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
光看文字可能略感觉有点抽象，那么我们可以结合我们生活实际的东西去理解它
这是我们熟悉的火车结构有一节一节的车厢，火车头它们之间用链条链起彼此，到末尾只有一个空链条。
那么，我们便可以联想出我们大厂必备的数据结构之一，链表。
链条其实对应我们链表的指针，而车厢对应我们链表中一个又一个节点
基于上面的火车，我们来引出链表的结构：
对于一个节点来说，链表中存着它要存储的数据和一个指向下一个节点的指针，方便能找到一个链表结构。
而对于所有的火车车厢组合而成的链表结构，就长成下面这样：
更抽象一点，在计算机中是这样的：
观察发现，链表内存的指针指向的是下一个链表节点的地址，每一个链表节点亦如此。plist是指向整个链表的指针，维护整个链表结构。形式上指向头结点。尾结点没有指向下一个节点，所以我们自然而然地将其置为空。
所以，理解了链表，我们再回过头看上面说的物理结构不连续和逻辑结构连续：逻辑结构连续是因为彼此之间有指针链接，可以通过头结点顺着找下去遍历和找到每一个节点。而物理结构不连续，浅显看来，就是上面每个不连续的地址，在计算机世界中其实是这样的：
相比于数组，它在同一块空间的不同位置创建节点，位置，地址是由系统分配和决定的。彼此之间是离散状态，不像数组那样连续开辟，所以说他是物理结构不连续。
2.链表的分类
实际中链表的结构非常多样，以下情况组合起来就有222=8种链表结构：
- 单向或者双向
如果是双向链表，那么一个节点就会存储两个指针，分别指向前一个节点和后一个节点。相比于单向链表，他可以从后往前遍历，找到前面的链表节点。第一个节点的前驱指针和末尾节点的next指针都会指向空。 - 带头或者不带头
我们上面看到的这个链表，就是一个带头链表，上面有一个带head指针的节点没有存数据，head指针指向下一个带有数据的节点，这个带head的节点就叫做哨兵位，本身不存储有效的数据，在某些特定场合是有奇效！！ - 循环或者非循环
循环的链表尾结点的指针指向头节点，可以在遍历完链表后从尾结点回到头结点。
虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
1.单向无头不循环链表
2.双向循环带头链表
那么它们为什么会是我们具体学习的重点呢？
事实上：
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
带头双向循环链表：结构最复杂，一般用在单独存储数据。**实际中使用的链表数据结构，都是带头双向循环链表。**另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。
那么好，我们就来正式地整代码
二、单链表的实现
1.单链表的结构和要实现的功能
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SLTNode;
- 1
- 2
- 3
- 4
- 5
- 6
实现的功能：
和顺序表一样，链表也有自己的增删查改和销毁，也是我们重点的研究和实现内容，链表的初始化，是直接用链表的插入代替的，因为插入是需要开辟空间，存放数据和指针的。就相当于初始化的过程了。
所以，我们先设计一个头文件，再去逐一测试和实现函数：
SList.h
#pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SLTNode; //链表打印 void SLTPrint(SLTNode* phead); //链表尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x); //头插 void SLTPushFront(SLTNode** pphead, SLTDataType x); //尾删 void SLTPopBack(SLTNode** pphead); //头删 void SLTPopFront(SLTNode** pphead); //节点查找 SLTNode* SLTFind(SLTNode** pphead, SLTDataType x); //任意位置之前插入 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //指定位置之后插入 void SLTInsertAfter(SLTNode* pos, SLTDataType x); //删除任意位置之前节点 void SLTErase(SLTNode** pphead, SLTNode* pos); //删除指定位置之后的节点 void SLTEraseAfter(SLTNode* pos); //销毁链表 void SLTDestroy(SLTNode** pphead);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
2.链表的准备，打印和销毁
ps：头文件在上文中已经有了，测试调用函数的代码是放在测试文件Test.c中，而函数实现的代码是放在SList.c文件中的。
2.0准备
在文件Test.c中：
void SListTest02() {
SLTNode* plist = NULL;
}
int main()
{
SListTest02();
return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
2.1打印
为了方便测试和研究，我们先设计一个链表打印函数：
在文件SList.c中：
void SLTPrint(SLTNode* phead) { //打印
SLTNode* pcur = phead;
while (pcur)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("NULL\n");
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
这一段是Test.c的main函数中调用函数的代码：
SLTPrint(plist);
- 1
定义pcur的目的是为了不改变原来的head的指针，pcur->data是结构体指针访问成员的写法，C语言阶段打下的基础正是在数据结构和以后C++阶段发挥的作用。
上面相当于是一个链表的遍历，每打印一个链表节点存储的数据，链表指针pcur就移动到下一个节点。以此往复，只到pcur指向空为止。
下面给大家看一个自制的GIF方便大家理解：
2.2 销毁
void SLTDestroy(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
这里就有小伙伴会疑惑了，看不懂为什么突然来了一个传二级指针？
这也是我们在链表这一块遇到的第一个拦路虎，是一个不太好理解的难点。但是只要C语言基础够扎实，还是能够弄明白原因的。
SLTDestroy(&plist);
- 1
对比我们main函数中传参的代码，可以尝试先理解理解。(*￣︶￣)
在讲这个问题之前，我们先来回顾指针中的知识：
二级指针
A(即B的地址)是指向指针的指针，称为二级指针，用于存放二级指针的变量称为二级指针变量．根据B的不同情况，二级指针又分为指向指针变量的指针和指向数组的指针。——百度百科
我们知道，指针存放变量的地址**，地址本身也可被修改，改变。所以说，指针（即地址）它本身也是一种变量**，既然是变量，也就有对应的地址，有对应的指针指向他。而指向指针的指针我们就叫它二级指针，它指向的是一级指针的地址
结合这个图，我们再谈一谈变量，一级指针，二级指针之间的关系：
上面这个图描述的是指针指向的内容和各级指针的指向关系
二级指针存的是一级指针的地址0x0012ff48，一级指针存储的是变量a的地址0x0012ff50.小结一下，就是二级指针存放一级指针的地址，指向一级指针。一级指针的存放变量的地址，指向变量。一级指针解引用是拿到变量，二级指针解引用拿到的是一级指针。
但是光知道二级指针其实是不够的，我们还要知道函数传参的本质，函数传参并不是把参数真正地传给函数让其修改。实际上，形参是实参的一份临时拷贝，函数修改的其实是形式参数而不是实际参数。换句话说，形参的改变不影响实参的结果。
回到上面传二级指针的问题，如果我们不用pphead接收而是用*phead接收，那根据函数传参的特点，*phead是plist地址的一份临时拷贝，*phead的改变不影响plist，不能达到我们想要的效果。而函数传值调用是拷贝实参，不能解决问题，函数传址调用是借助指针访问，实参会发生改变。plist指向头结点。我们的目的正是改变plist，所以我们要传plist指针的地址，也就是二级指针/**pphead。
void SLTDestroy(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
再来分析这个代码，我们先保证二级指针和一级指针都不为空，再实现遍历式的销毁。这里还是有一个要点我们需要在销毁之前用一个临时指针next把pcur的下一个节点存储起来，不然，我们free掉pcur后，就找不到pcur->next，pcur的下一个节点了。最后全部free完会剩下一个*pphead没有置空，把它置空避免内存泄漏就可以了，我们后面常常要用到类似这样的操作，避免空访问指针造成报错。
3.链表的增删查改
3.1尾插和头插
既然是插入，那要开辟空间创建节点，所以要现有SLTBuyNode函数
SLTNode* SLTBuyNode(SLTDataType x) { //创建节点
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
newnode->data = x;
newnode->next = NULL;
return newnode;
}
- 1
- 2
- 3
- 4
- 5
- 6
在尾插时分为两种情况，链表为空和链表不为空
void SLTPushBack(SLTNode** pphead, SLTDataType x) { //尾插 assert(pphead); SLTNode* newnode = SLTBuyNode(x); //链表为空，新节点作为phead if (*pphead == NULL) { *pphead = newnode; return; } SLTNode* ptail = *pphead; while (ptail->next) { ptail = ptail->next; } //链表不为空，循环找尾，新节点作为尾结点 ptail->next = newnode; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
结合动图演示理解代码：
链表为空：
链表不为空：
头插也是类似的：
void SLTPushFront(SLTNode** pphead, SLTDataType x) { //头插
assert(pphead);
SLTNode* newnode = SLTBuyNode(x);
//newnode *pphead
newnode->next = *pphead;
*pphead = newnode;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
动画：
3.2头删和尾删
尾删：
void SLTPopBack(SLTNode** pphead) { //尾删 //链表不能为空 assert(*pphead && pphead); //分链表只有一个节点和多个节点的情况 if ((*pphead)->next == NULL) { free(*pphead); *pphead = NULL; return; } SLTNode* ptail = *pphead; SLTNode* prev = NULL; while (ptail->next) { prev = ptail; ptail = ptail->next; } prev->next = NULL;//尾删，最后一个节点置空 //销毁尾结点 free(ptail); ptail = NULL; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
头删：
void SLTPopFront(SLTNode** pphead) {
assert(pphead && *pphead);
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
- 1
- 2
- 3
- 4
- 5
- 6
3.3节点查找
Test.c
SLTNode* FindRet = SLTFind(&plist, 2);//
if (FindRet) {
printf("找到了!\n");
}
else {
printf("未找到!\n");
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
SList.c
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
assert(pphead);
SLTNode* pcur = *pphead;
while (pcur) {
if (pcur->data == x) {
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
这里设置成返回指针，是为了给下文一些指定位置相关的问题做铺垫。这个函数的返回判断单独拎出来到Test.c中，便于自己测试这个函数写的对不对。
3.4任意位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) { assert(pphead && pos && *pphead); SLTNode* newnode = SLTBuyNode(x); //分类，pos刚好是头节点和pos不是头节点的情况 if (pos == *pphead) { //头插 SLTPushFront(pphead, x); return; } SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } prev->next = newnode; newnode->next = pos; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
有上面的经验，我们分情况去实现
头结点为空，那就是直接头插，直接调用上面写过的函数
头结点不为空，那就遍历去找前驱节点，借助前驱节点去插入
下面的演示例子，目标：pos指向d3节点，要在d3节点之前插入d5节点，d5是newnode的节点
3.5任意位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
- 1
- 2
- 3
- 4
- 5
- 6
过程和指定位置前插入相比，少了遍历找前驱节点这一步。但是这里有一点容易错要注意，不能先写pos->next=newnode,否则，你会找不到pos的next节点，除非你用一个临时指针把pos->next存起来。但在这里，我们最好先处理newnode的next，以免破坏pos->next，导致找不到。
所以，为什么我们任意位置的插入和删除要分前和后呢？其实它们的思路看似相同，但在细节上差异较大，一不小心就有可能弄出bug。这和链表本身的特性有很大的关联，因为单链表的单向性，可以往前不能往后。不像数组那样可以随意访问数据，所以遍历就成了链表中常常做的事情，这也是**链表的一大缺陷所在，会增加程序的运行和消耗。**有时代码的顺序像上面会影响程序的运行，小心驶得万年船，链表中随时可能找不到我们本来能访问到的节点，这一点，在我们后面学习的双向链表中也是很常见的。
3.6任意位置之前删除
void SLTErase(SLTNode** pphead, SLTNode* pos) { assert(pphead && *pphead && pos); if (*pphead == pos) { SLTPopFront(pphead); return; } SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } prev->next = pos->next; free(pos); pos = NULL; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
不管是增还是删，都要考虑周全，要留个心眼，防止链表为空。链表为空无法删除，要及时用assert断言拦下，pos超出链表的个数，也要拦下。不只是pphead不为空。
当只有一个节点的时候，相当于头删功能，当不止一个节点的时候，如下演示：
3.7任意位置之后删除
void SLTEraseAfter(SLTNode* pos)
{
assert(pos && pos->next);
SLTNode* del = pos->next;
pos->next = pos->next->next;
free(del);
del = NULL;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
同样，这里也是要记住pos->next的。以免找不到。
全套代码（含测试）
SList.h
#pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SLTNode; //链表打印 void SLTPrint(SLTNode* phead); //链表尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x); //头插 void SLTPushFront(SLTNode** pphead, SLTDataType x); //尾删 void SLTPopBack(SLTNode** pphead); //头删 void SLTPopFront(SLTNode** pphead); //节点查找 SLTNode* SLTFind(SLTNode** pphead, SLTDataType x); //任意位置插入 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //指定位置插入 void SLTInsertAfter(SLTNode* pos, SLTDataType x); //删除任意节点 void SLTErase(SLTNode** pphead, SLTNode* pos); //删除指定位置之后的节点 void SLTEraseAfter(SLTNode* pos); //销毁链表 void SLTDestroy(SLTNode** pphead);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
SList.c
#define _CRT_SECURE_NO_WARNINGS #include "SList.h" void SLTPrint(SLTNode* phead) { //打印 SLTNode* pcur = phead; while (pcur) { printf("%d->", pcur->data); pcur = pcur->next; } printf("NULL\n"); } SLTNode* SLTBuyNode(SLTDataType x) { //创建节点 SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); newnode->data = x; newnode->next = NULL; return newnode; } void SLTPushBack(SLTNode** pphead, SLTDataType x) { //尾插 assert(pphead); SLTNode* newnode = SLTBuyNode(x); //链表为空，新节点作为phead if (*pphead == NULL) { *pphead = newnode; return; } SLTNode* ptail = *pphead; while (ptail->next) { ptail = ptail->next; } //链表不为空，循环找尾，新节点作为尾结点 ptail->next = newnode; } void SLTPushFront(SLTNode** pphead, SLTDataType x) { //头插 assert(pphead); SLTNode* newnode = SLTBuyNode(x); //newnode *pphead newnode->next = *pphead; *pphead = newnode; } void SLTPopBack(SLTNode** pphead) { //尾删 //链表不能为空 assert(*pphead && pphead); //分链表只有一个节点和多个节点的情况 if ((*pphead)->next == NULL) { free(*pphead); *pphead = NULL; return; } SLTNode* ptail = *pphead; SLTNode* prev = NULL; while (ptail->next) { prev = ptail; ptail = ptail->next; } prev->next = NULL;//尾删，最后一个节点置空 //销毁尾结点 free(ptail); ptail = NULL; } void SLTPopFront(SLTNode** pphead) { assert(pphead && *pphead); SLTNode* next = (*pphead)->next; free(*pphead); *pphead = next; } SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) { assert(pphead); SLTNode* pcur = *pphead; while (pcur) { if (pcur->data == x) { return pcur; } pcur = pcur->next; } return NULL; } void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) { assert(pphead && pos && *pphead); SLTNode* newnode = SLTBuyNode(x); //分类，pos刚好是头节点和pos不是头节点的情况 if (pos == *pphead) { //头插 SLTPushFront(pphead, x); return; } SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } prev->next = newnode; newnode->next = pos; } void SLTInsertAfter(SLTNode* pos, SLTDataType x) { assert(pos); SLTNode* newnode = SLTBuyNode(x); newnode->next = pos->next; pos->next = newnode; } void SLTErase(SLTNode** pphead, SLTNode* pos) { assert(pphead && *pphead && pos); if (*pphead == pos) { SLTPopFront(pphead); return; } SLTNode* prev = *pphead; while (prev->next != pos) { prev = prev->next; } prev->next = pos->next; free(pos); pos = NULL; } void SLTEraseAfter(SLTNode* pos) { assert(pos && pos->next); SLTNode* del = pos->next; pos->next = pos->next->next; free(del); del = NULL; } void SLTDestroy(SLTNode** pphead) { assert(pphead && *pphead); SLTNode* pcur = *pphead; while (pcur) { SLTNode* next = pcur->next; free(pcur); pcur = next; } *pphead = NULL; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
Test.c
#define _CRT_SECURE_NO_WARNINGS #include "SList.h" void SListTest02() { //初始化 SLTNode* plist = NULL;//定义链表指针 //---------------------------------------------------------尾插 SLTPushBack(&plist, 1); SLTPushBack(&plist, 2); SLTPushBack(&plist, 3); SLTPushBack(&plist, 4); /*SLTPrint(plist);*/ //---------------------------------------------------------头插 //SLTPushFront(&plist, 7); //SLTPushFront(&plist, 6); //SLTPushFront(&plist, 5); /*SLTPrint(plist);*/ //---------------------------------------------------------尾删 //SLTPopBack(&plist); //SLTPrint(plist); //SLTPopBack(&plist); //SLTPrint(plist); //SLTPopBack(&plist); //SLTPrint(plist); //SLTPopBack(&plist); //SLTPrint(plist); //SLTPopBack(&plist); //SLTPrint(plist); //-------------------------------------------------------头删 //SLTPopFront(&plist); //SLTPrint(plist); //------------------------------------------------- - 查找 SLTNode* FindRet = SLTFind(&plist, 2);// if (FindRet) { printf("找到了!\n"); } else { printf("未找到!\n"); } //在指定位置前，后插入数据 /*SLTInsert(&plist, FindRet, 100); SLTPrint(plist);*/ /*SLTInsertAfter( FindRet, 100); SLTPrint(plist);*/ ---------------------------------------------------删除pos节点 //SLTErase(&plist, FindRet); //SLTPrint(plist); ---------------------------------------------------删除pos之后的节点 SLTEraseAfter(FindRet); SLTPrint(plist); //---------------------------------------------------销毁链表 SLTDestroy(&plist); } int main() { SListTest02(); return 0; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
小结
今天我们具体学习了链表的前两章，本篇文章除了图片，本人尝试着使用动画的形式代替了一部分文字和静图，方便大家更好地理解链表和程序运行的过程。当然，链表世界不止于此，链表还有各种OJ中的应用和操作，还有双向带头循环链表，以及各种算法中，其他数据结构中，C++中我们还会再深入研究链表结构的。欲知后事如何，且听下回分解，我们下期再见！
创作不易，还请各位多多支持，求求三连谢谢
