热门标签
热门文章
- 1SpringBoot整合ES_springboot 集成es
- 2MYSQL的SWITCH语句和循环语句_mysql switch
- 3大学生搜题神器网站？分享七个支持答案和解析的工具 #职场发展#学习方法_哪里可以免费查答案的网站
- 4PLSQL Devolper [自定义快捷键和代码块]_plsql美化sql快捷键
- 5第三届“中国法研杯”司法人工智能挑赛（CAIL2020）即将启动
- 6iOS-OC实现定时器_oc定时器使用
- 7物联网应用开发--Wi-Fi通信（ESP8266模块：STA、AP、STA+AP）_stm32esp8266ap
- 81-5G基站是如何起名的？NR，gNB，en-gNB，ng-eNB，EN-DC，NE-DC，NGEN-DC，NG-RAN......_卫星上的enb是什么意思
- 9数据结构（C语言版）——8、树_c语言什么是树形结构
- 10会计继续教育考试搜题软件？分享八个搜题直接出答案的软件 #知识分享#微信#笔记_会计继续教育搜题
当前位置: article > 正文
【数据结构】线性表之《无头单链表》超详细实现
作者：木道寻08 | 2024-06-24 17:59:23
赞
踩
【数据结构】线性表之《无头单链表》超详细实现
前言：在前一章节成功实现了顺序表后，对数据结构的理解已经初具雏形，但这只是启蒙阶段，接下来我们将进入链表的探索学习。链表作为数据结构的另一种形式，不仅仅是简单的表述，它承载了更多的内涵和抽象思维，有助于深入理解数据在计算机科学中的精髓。
一.链表的概念及结构
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
typedef int SLLDataType; //增强程序的可维护性
typedef struct SLLNode
{
SLLDataType data; //数据域
struct SLLNode* next; //指针域
}SLLNode;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
实际中要实现的链表结构非常多样（2^3=8中）。
- 单向，双向。
- 带头，不带头。
- 循环，非循环。
虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
-
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 -
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
来很多优势，实现反而简单了，后面我们代码实现了就知道了。
二.顺序表与链表的区别与联系
顺序表：
优点：空间连续，支持随机访问。
缺点：如果空间不够要增容，增容会付出一定的性能消耗，其次可能存在一定的空间浪费；头部或者中部左右的插入 ，删除效率低——>O(N)。
链表：
优点：任意位置的插入删除的时间复杂度为O(1)；没有增容消耗，按需申请节点空间，但是不用了记得直接释放。
缺点：以节点为单位存储，不支持随机访问。
三.单链表的实现
1.创建单链表
链表由节点组成，每个节点要存放数据与下一个节点的地址（为了找到下一个节点）。由于存放的是不同类型的数据，所以定义一个结构体，成员则有：数据域，指针域。
单链表：指向该节点的指针。
typedef int SLLDataType; //增强程序的可维护性
typedef struct SLLNode //单链表节点
{
SLLDataType data; //数据域
struct SLLNode* next; //指针域
}SLLNode;
SLLNode* plist;//单链表
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2.初始化单链表
注意：以下函数中的参数 phead 对应 plist；pphead 对应 &plist。
为什么这么做呢？
答：值传递与地址传递的问题。
- 无需改变链表的话（比如：打印链表，查找数据等…），只需传入值。
- 需要改变链表的话（头插，头删等…），需要传入地址。
- 即使 plist 是一级指针，但是传参时仍会创建 phead 存放 plist 。本质依旧是传值。
一般初始化我们都习惯赋值为0，即单链表plist（*pphead）赋值为NULL。
void SLLInit(SLLNode** pphead)
{
assert(pphead); //断言
*pphead = NULL;
}
- 1
- 2
- 3
- 4
- 5
3.购买节点
由于头插，尾插，按位置插入链表，都要先准备一个节点。为了减少代码的重复，直接对其进行封装，创建新节点的时候直接调用该接口就行。
SLLNode* BuyNode(SLLDataType x)
{
SLLNode* newNode = (SLLNode*)malloc(sizeof(SLLNode)); //申请节点空间
if (newNode == NULL) //申请失败
{
perror("malloc fail");
exit(1);
}
//申请成功
newNode->data = x;
newNode->next = NULL;
return newNode; //返回新节点
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
4.打印单链表
定义一个指针指向单链表，利用NULL这一结束条件，循环遍历打印即可，较为简单。
void SLLPrint(SLLNode* phead)
{
SLLNode* cur = phead; //定位单链表的头节点
while (cur != NULL)
{
printf("%d->", cur->data);
cur = cur->next; //更新为下一节点
}
printf("NULL\n");
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
5.插入操作
1.头插
头插思想：创建新节点，新节点的指针域指向单链表的头节点（实际上就是单链表），再更新单链表的头节点指向新节点。
void SLLPushFront(SLLNode** pphead, SLLDataType x)
{
assert(pphead);
SLLNode* newNode = BuyNode(x); //购买节点
newNode->next = *pphead; //新节点头插
*pphead = newNode; //更新单链表的头节点
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
2.尾插
尾插思想
- 当单链表为NULL：单链表的头指针指向新节点。
- 当单链表不为NULL：找到尾节点，尾节点的指针域指向新节点。
void SLLPushBack(SLLNode** pphead, SLLDataType x) { assert(pphead); SLLNode* newNode = BuyNode(x); //购买节点 if (*pphead == NULL) //单链表为空 { *pphead = newNode; //更新单链表的头节点 } else //单链表不为空 { SLLNode* tail = *pphead; //寻找尾节点 while (tail->next != NULL) { tail = tail->next; } tail->next = newNode; //尾节点，链接新节点 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
3.给定位置之前插入
思路：
- 当给定的位置恰好是头节点的地址时，直接调用头插。
- 否则要寻找 pos 指向的节点的前一个节点，新节点的指针域指向 pos 指向的节点，前一个节点的指针域指向新节点。
void SLLInsert(SLLNode** pphead, SLLNode* pos, SLLDataType x) { assert(pphead); assert(pos); if (pos == *pphead) //pos是头节点的地址 { SLLPushFront(pphead, x); //直接头插 } else { SLLNode* newNode = BuyNode(x); //购买节点 SLLNode* prev = *pphead; //定位pos前一个节点 while (prev->next != pos) { prev = prev->next; } //插入操作 newNode->next = pos; prev->next = newNode; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
6.删除操作
1.头删
思路：
- 当单链表为NULL：无需操作。
- 当单链表不为NULL：先保存头节点的下一个节点的指针，再释放头指针，最后更新头节点为保存的哪个头节点。
void SLLPopFront(SLLNode** pphead) { assert(pphead); //单链表为空 if (*pphead == NULL) { return; //无需释放，直接退出 } else { SLLNode* cur = (*pphead)->next; //定位头节点的下一个节点 free(*pphead); //释放头节点 *pphead = cur; //更新单链表的头节点 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
2.尾删
思路略复杂：
- 当单链表为NULL：无需操作。
- 当单链表只有一个节点：释放头节点，将头指针置为NULL。
- 当单链表有多个节点：先找到尾节点的前一个节点并保存，释放尾节点，将保存的节点的指针域置为NULL。
void SLLPopBack(SLLNode** pphead) { assert(pphead); //单链表为空 if (*pphead == NULL) { return; //无需释放，直接退出 } //单链表只有一个节点 else if ((*pphead)->next == NULL) //注意：加上括号 { free(*pphead); //释放头节点 *pphead = NULL; //单链表置为NULL } //单链表有多个节点 else { SLLNode* prev = NULL; //定位尾节点前一个节点 SLLNode* tail = *pphead; //定位尾节点 while (tail->next != NULL) { prev = tail; tail = tail->next; } free(tail); //释放尾节点 tail = NULL; //置为NULL，预防野指针 prev->next = NULL; //变为尾节点后置为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
3.删除给定位置的结点
思路：
- 当待删除的节点为头节点时，直接调用头删即可。
- 否则保存待删除的节点的前一个节点，将该节点的指针域指向待删除的节点的下一个节点，最后释放待删除的节点即可。
void SLLErase(SLLNode** pphead, SLLNode* pos) { assert(pphead); assert(pos); if (pos == *pphead) //pos是头节点的地址 { SLLPopFront(pphead); //直接头删 } else { SLLNode* prev = *pphead; //定位pos前一个节点 while (prev->next != pos) { prev = prev->next; } prev->next = pos->next; //删除过程 free(pos); //释放节点 pos = NULL; //置为NULL，预防野指针 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
7.查找数据
思路：循环遍历单链表即可，找到返回地址，未找到返回NULL。
SLLNode* SLLFind(SLLNode* phead, SLLDataType x)
{
SLLNode* cur = phead; //定位值为x的节点
while (cur != NULL) //遍历单链表
{
if (cur->data == x)
{
return cur; //找到了，返回节点的地址
}
cur = cur->next;
}
return NULL; //找不到，返回NULL
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
8.修改数据
思路：直接通过SLLFind函数得到地址，在该处修改即可，较为简单，同时SLLErase与SLLInsert函数都要通过SLLFind函数得到地址。
void SLLModify(SLLNode** pphead, SLLNode* pos, SLLDataType x)
{
assert(pphead);
assert(pos); //防止对NULL解引用导致程序崩溃
pos->data = x; //直接修改就行了
}
- 1
- 2
- 3
- 4
- 5
- 6
9.求单链表长度
思路：利用头指针，向后循环遍历直到不为空即可。
int SLLLength(SLLNode* phead)
{
int len = 0;
SLLNode* cur = phead;
while (cur != NULL)
{
cur = cur->next;
len++;
}
return len;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
10.清空单链表
思路：这里不像顺序表一样，顺序表只需释放一个指针arr（连续开辟的空间），而单链表物理上是不连续的，需要释放每一个节点，循环遍历单链表即可。
void SLLClear(SLLNode** pphead)
{
assert(pphead);
//从头开始逐个释放
SLLNode* cur = *pphead;
while (cur != NULL)
{
*pphead = cur->next;
free(cur);
cur = *pphead;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
11.销毁单链表
思路：自认为销毁与清空单链表没有太大区别
void SLLDestory(SLLNode** pphead)
{
assert(pphead);
SLLClear(pphead); //与清空单链表无区别
}
- 1
- 2
- 3
- 4
- 5
- 6
四.模块化源代码
1.SingleLinkList.h
//#pragma once 防止头文件被重复包含，导致效率下降 #ifndef __SINGLELINKLIST_H__ #define __SINGLELINKLIST_H__ #include<stdio.h> #include<stdlib.h> #include<assert.h> typedef int SLLDataType; //增强程序的可维护性 typedef struct SLLNode { SLLDataType data; //数据域 struct SLLNode* next; //指针域 }SLLNode; void SLLInit(SLLNode** pphead);//初始化单链表（需要修改单链表，传地址） SLLNode* BuyNode(SLLDataType x);//购买节点 void SLLPrint(SLLNode* phead);//打印单链表（无需修改单链表，传值） void SLLPushBack(SLLNode** pphead, SLLDataType x);//尾插（同理，传地址） void SLLPushFront(SLLNode** pphead, SLLDataType x);//头插 void SLLPopBack(SLLNode** pphead);//尾删 void SLLPopFront(SLLNode** pphead);//头删 SLLNode* SLLFind(SLLNode* phead, SLLDataType x);//查找 void SLLInsert(SLLNode** pphead, SLLNode* pos, SLLDataType x);//插入：通过《SLLFind函数》找到pos，在pos前插入x void SLLErase(SLLNode** pphead, SLLNode* pos);//删除：通过《SLLFind函数》找到pos，删除pos位置的值 void SLLModify(SLLNode** pphead, SLLNode* pos, SLLDataType x);//修改：通过《SLLFind函数》找到pos，修改pos位置的值 int SLLLength(SLLNode* phead);//求单链表的长度 void SLLClear(SLLNode** pphead);//清空单链表 void SLLDestory(SLLNode** pphead);//销毁单链表 #endif
- 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
2.SingleLinkList.c
#define _CRT_SECURE_NO_WARNINGS 1 #include"SingleLinkList.h" void SLLInit(SLLNode** pphead) { assert(pphead); //断言 *pphead = NULL; } SLLNode* BuyNode(SLLDataType x) { SLLNode* newNode = (SLLNode*)malloc(sizeof(SLLNode)); //申请节点空间 if (newNode == NULL) //申请失败 { perror("malloc fail"); exit(1); } //申请成功 newNode->data = x; newNode->next = NULL; return newNode; //返回新节点 } void SLLPrint(SLLNode* phead) { SLLNode* cur = phead; //定位单链表的头节点 while (cur != NULL) { printf("%d->", cur->data); cur = cur->next; //更新为下一节点 } printf("NULL\n"); } void SLLPushBack(SLLNode** pphead, SLLDataType x) { assert(pphead); SLLNode* newNode = BuyNode(x); //购买节点 if (*pphead == NULL) //单链表为空 { *pphead = newNode; //更新单链表的头节点 } else //单链表不为空 { SLLNode* tail = *pphead; //寻找尾节点 while (tail->next != NULL) { tail = tail->next; } tail->next = newNode; //尾节点，链接新节点 } } void SLLPushFront(SLLNode** pphead, SLLDataType x) { assert(pphead); SLLNode* newNode = BuyNode(x); //购买节点 newNode->next = *pphead; //新节点头插 *pphead = newNode; //更新单链表的头节点 } void SLLPopBack(SLLNode** pphead) { assert(pphead); //单链表为空 if (*pphead == NULL) { return; //无需释放，直接退出 } //单链表只有一个节点 else if ((*pphead)->next == NULL) //注意：加上括号 { free(*pphead); //释放头节点 *pphead = NULL; //单链表置为NULL } //单链表有多个节点 else { SLLNode* prev = NULL; //定位尾节点前一个节点 SLLNode* tail = *pphead; //定位尾节点 while (tail->next != NULL) { prev = tail; tail = tail->next; } free(tail); //释放尾节点 tail = NULL; //置为NULL，预防野指针 prev->next = NULL; //变为尾节点后置为NULL } } void SLLPopFront(SLLNode** pphead) { assert(pphead); //单链表为空 if (*pphead == NULL) { return; //无需释放，直接退出 } else { SLLNode* cur = (*pphead)->next; //定位头节点的下一个节点 free(*pphead); //释放头节点 *pphead = cur; //更新单链表的头节点 } } SLLNode* SLLFind(SLLNode* phead, SLLDataType x) { SLLNode* cur = phead; //定位值为x的节点 while (cur != NULL) //遍历单链表 { if (cur->data == x) { return cur; //找到了，返回节点的地址 } cur = cur->next; } return NULL; //找不到，返回NULL } void SLLInsert(SLLNode** pphead, SLLNode* pos, SLLDataType x) { assert(pphead); assert(pos); if (pos == *pphead) //pos是头节点的地址 { SLLPushFront(pphead, x); //直接头插 } else { SLLNode* newNode = BuyNode(x); //购买节点 SLLNode* prev = *pphead; //定位pos前一个节点 while (prev->next != pos) { prev = prev->next; } //插入操作 newNode->next = pos; prev->next = newNode; } } void SLLErase(SLLNode** pphead, SLLNode* pos) { assert(pphead); if (pos == *pphead) //pos是头节点的地址 { SLLPopFront(pphead); //直接头删 } else { SLLNode* prev = *pphead; //定位pos前一个节点 while (prev->next != pos) { prev = prev->next; } prev->next = pos->next; //删除过程 free(pos); //释放节点 pos = NULL; //置为NULL，预防野指针 } } void SLLModify(SLLNode** pphead, SLLNode* pos, SLLDataType x) { assert(pphead); assert(pos); //防止对NULL解引用导致程序崩溃 pos->data = x; //直接修改就行了 } int SLLLength(SLLNode* phead) { int len = 0; SLLNode* cur = phead; while (cur != NULL) { cur = cur->next; len++; } return len; } void SLLClear(SLLNode** pphead) { assert(pphead); //从头开始逐个释放 SLLNode* cur = *pphead; while (cur != NULL) { *pphead = cur->next; free(cur); cur = *pphead; } } void SLLDestory(SLLNode** pphead) { assert(pphead); SLLClear(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
- 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
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
3.test.c
#define _CRT_SECURE_NO_WARNINGS 1 #include"SingleLinkList.h" enum //匿名枚举 { EXIT, PUSHBACK, PUSHFRONT, POPBACK, POPFRONT, INSERT, ERASE, FIND, MODIFY, PRINT, LENGTH, CLEAR }; void Menu() { printf("*************单链表************\n"); printf("****1.尾插 2.头插****\n"); printf("****3.尾删 4.头删****\n"); printf("****5.插入 6.删除****\n"); printf("****7.查找 8.修改****\n"); printf("****9.打印 10.长度****\n"); printf("***11.清空 0.退出****\n"); printf("*******************************\n"); } int main() { SLLNode* plist; SLLInit(&plist); int select = 0; //操作选项 SLLDataType value; //接收值 SLLDataType value1; //接收值 SLLNode* pos = NULL; //接收指针 do { Menu(); printf("请输入您的操作："); scanf("%d", &select); switch (select) { case EXIT: printf("退出单链表!\n"); break; case PUSHBACK: printf("请输入您要尾插的值(输入-1代表结束)："); while ((scanf("%d", &value), value != -1)) //逗号表达式 { SLLPushBack(&plist, value); } break; case PUSHFRONT: printf("请输入您要头插的值(输入-1代表结束)："); do { scanf("%d", &value); if (value != -1) { SLLPushFront(&plist, value); } } while (value != -1); break; case POPBACK: SLLPopBack(&plist); break; case POPFRONT: SLLPopFront(&plist); break; case INSERT: printf("请输入您要插入到《何值前面》以及《插入的值》："); scanf("%d %d", &value1, &value); pos = SLLFind(plist, value1); if (pos != NULL) { SLLInsert(&plist, pos, value); } else { printf("该值不存在，无法插入!\n"); } break; case ERASE: printf("请输入您要删除的值："); scanf("%d", &value); pos = SLLFind(plist, value); if (pos != NULL) { SLLErase(&plist, pos); } else { printf("该值不存在，无法删除!\n"); } break; case FIND: printf("请输入您要查找的值："); scanf("%d", &value); pos = SLLFind(plist, value); if (pos == NULL) { printf("您要查找的值不存在!\n"); } else { printf("您要查找的值存在!\n"); } break; case MODIFY: printf("请输入您要《要修改的值》以及《修改后的值》："); scanf("%d %d", &value1, &value); pos = SLLFind(plist, value1); if (pos != NULL) { SLLModify(&plist, pos, value); } else { printf("该值不存在，无法修改!\n"); } break; case PRINT: SLLPrint(plist); break; case LENGTH: printf("单链表的长度：%d\n", SLLLength(plist)); break; case CLEAR: SLLClear(&plist); break; } } while (select); SLLDestory(&plist); //记得最后要销毁，防止内存泄漏 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
- 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
五.链表必做OJ题
以后还会更新其余的链表：带头，循环，双链等等组合的链表。
创作不易，如果能帮到你的话能赏个三连吗？感谢啦！！！
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/753527
推荐阅读
相关标签
