深入剖析单链表：从原理到实战应用-海口c网

深入剖析单链表：从原理到实战应用

顺序表的问题
单链表
- 单链表与顺序表区别
- 相关概念
- 链表定义
- 单链表定义
- 存储结构
单链表的操作实现
- 代码全貌与功能介绍
- 单链表的功能说明
- 代码效果展示
- 代码详解
- - SList.h
  - SList.c
  - test.c
总结

💻作者简介：曾与你一样迷茫，现以经验助你入门数据结构。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：硬核数据结构与算法
✨代码趣语：巧妙的数据结构搭配简单的代码，远比反过来效果好得多。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述

线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中任一元素。然而，从另一方面来看，这个特点也铸成了这种存储结构的弱点：在作插入或删除操作时，需移动大量元素。本篇博客将讨论线性表的另一种表示方法 - - - 链式存储结构，由于它不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但同时也失去了顺序表可随机存取的优点。

顺序表的问题

中间 / 头部的插入删除，时间复杂度为 O(N)。
增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
增容一般是呈 2 倍的增长，势必会有一定的空间浪费。例如当前容量为 100，满了以后增容到 200，我们再继续插入了 5 个数据，后面没有数据插入了，那么就浪费了 95 个数据空间。

单链表

单链表与顺序表区别

顺序表：使用一组地址连续的存储单元来依次存放线性表的结点，因此结点的逻辑顺序和物理顺序是一样的。

链表：使用一组任意的存储单元来存放线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表的逻辑顺序和物理顺序不一样相同。

链表定义

链表是一种 物理存储结构上非连续、非顺序 的存储结构，数据元素的 逻辑顺序 是通过链表中的 指针链接 次序实现的。

在这里插入图片描述

单链表定义

单链表是一种通过指针串联节点的动态数据结构，每个节点包含 数据域 和 指针域（指向下一个节点的地址）。与顺序表相比，它无需预先分配连续内存空间，插入和删除操作仅需修改指针指向，具有高效的动态性。但其访问节点必须从头遍历，时间复杂度为 O(n)。

存储结构

物理结构

物理结构是指数据元素及其逻辑关系在计算机内存中的具体存储方式，实实在在数据在内存中的变化，关注的是 “数据如何在硬件中实际存放”。它是机器视角下的实现模型，直接影响数据操作的效率。

在这里插入图片描述

逻辑结构

逻辑结构是从数据元素之间的逻辑关系角度出发，抽象描述数据元素之间的关联方式，不涉及数据的存储方式和具体实现。为了方便理解，形象化画出来的。它是用户视角下的数据模型，关注的是 “数据元素如何相互连接”。

在这里插入图片描述

单链表的操作实现

代码全貌与功能介绍

整个顺序表由三个主要文件构成：SList.h、SList.c 和 test.c。这种多文件的架构设计，有助于将不同功能模块分离，提高代码的可读性、可维护性与可扩展性。

SList.h

SList.h 包含了单链表所需的头文件引用、常量定义以及函数声明。

test.c

test.c 是单链表的主逻辑文件，负责处理用户输入和代码流程的控制。

SList.c

SList.c 则实现了单链表的具体功能函数。

下面展示完整代码。

读者可以将这段代码复制到自己的编译器中运行。

SList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//第一种写法
typedef int SLTDataType;
typedef struct SListNode
{SLTDataType data;struct SListNode* next;//指针的类型是结构体//SListNode* next;C语言不行,C++可以//STLnode* next;//编译器的查找规则,只能在重定义之后才能使用
}STLNode;
//第2种写法
//typedef int SLTDataType;
//
//struct SListNode
//{
//	SLTDataType data;
//	struct SListNode* next;//指针的类型是结构体
//	//SListNode* next;C语言不行,C++可以
//	//STLnode* next;//编译器的查找规则,只能在重定义之后才能使用
//};
//
//typedef struct SListNode STLNode;//创建结点并将值填入数据域中
STLNode* BuySTLNode(SLTDataType x);//输出
void STLPrint(STLNode* phead);//尾插
void STLPushBack(STLNode** phead, SLTDataType x);//头插
void STLPushFront(STLNode** pphead, SLTDataType x);//尾删
void STLPopBack(STLNode** phead);//头删
void STLPopFront(STLNode** pphead);//单链表查找
STLNode* STLFind(STLNode* pphead, SLTDataType x);//pos之前插入
void STLInsertFront(STLNode** pphead, STLNode* pos, SLTDataType x);//pos位置删除
void STLErase(STLNode** pphead, STLNode* pos);//pos后面插入
void STLInsertAfter(STLNode* pos, SLTDataType x);//pos位置后面删除
void STLEraseAfter(STLNode* pos);//链表销毁
void STLDestory(STLNode** pphead);//函数指针
void STLMiddlePos(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead, int num);void STLMiddlePush(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead);//从文件中加载
void STLLoadSList(STLNode** pphead);//将链表保存到文件
void STLSaveSList(STLNode** pphead);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
void menu()
{printf("****************************************************\n");printf("*****   0. STLExit          1. STLPrint        *****\n");printf("*****   2. STLPushBack      3. STLPopBack      *****\n");printf("*****   4. STLPushFront     5. STLPopFront     *****\n");printf("*****   6. STLInsertFront   7. STLErase        *****\n");printf("*****   8. STLInsertAfter   9. STLEraseAfter   *****\n");printf("****************************************************\n");
}
void test()
{int input = 0;STLNode* plist = NULL;STLLoadSList(&plist);do{menu();printf("请输入你想要进行的操作:>\n");scanf("%d", &input);switch (input){case 0:STLSaveSList(&plist);STLDestory(&plist);break;case 1:STLPrint(plist);break;case 2:STLMiddlePush(STLPushBack, &plist);break;case 3:STLPopBack(&plist);STLPrint(plist);break;case 4:STLMiddlePush(STLPushFront, &plist);break;case 5:STLPopFront(&plist);STLPrint(plist);break;case 6:STLMiddlePos(STLInsertFront, &plist, 6);break;case 7:STLMiddlePos(STLErase, &plist, 7);break;case 8:STLMiddlePos(STLInsertAfter, &plist, 8);break;case 9:STLMiddlePos(STLEraseAfter, &plist, 9);break;default:printf("无效输入,请重新输入\n");break;}} while (input);
}int main()
{test();return 0;
}

SList.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include "SList.h"
void STLPrint(STLNode* phead)
{//空的顺序表可以打印,只是数据为空//assert(phead);//不能STLNode* cur = phead;//while(cur)while (cur != NULL)//cur->next != NULL最后一个数据没有输出,不能写{printf("%d->", cur->data);cur = cur->next;//cur的地址不断覆盖,不能++,不能保证空间是连续的//一块空间的初始地址和结束地址不一样,一块空间的结束地址和下一块空间的起始地址一样}printf("NULL\n");
}
STLNode* BuySTLNode(SLTDataType x)
{STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));if (newnode == NULL){perror("SLPushBack");return NULL;}newnode->data = x;newnode->next = NULL;return newnode;
}
//上一个节点链接下一个节点的地址
//不为空链表的尾插,尾插的本质是原尾节点要存储新的尾节点的地址
void STLPushBack(STLNode** pphead, SLTDataType x)
{assert(pphead);//*pphead为地址一定不为空,值可以为空STLNode* newnode = BuySTLNode(x);if (*pphead == NULL){*pphead = newnode;}else{//找尾---尾结点STLNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;//错误---头结点//while (tail != NULL)//{//	tail = tail->next;//}//tail = newnode;}
}
void STLPushFront(STLNode** pphead, SLTDataType x)
{assert(pphead);STLNode* newnode = BuySTLNode(x);newnode->next = *pphead;*pphead = newnode;
}
//一定不能为空,要断言
//pphead
void STLPopBack(STLNode** pphead)
{//必须有数据才能删除//检查assert(pphead);assert(*pphead);//if (*pphead == NULL)//{//	return;//}//只有一个节点//有多个节点if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}else{//方法1//找尾STLNode* prev = NULL;STLNode* tail = *pphead;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);tail = NULL;//tail是局部变量prev->next = NULL;//方法2//STLNode* tail = *pphead;//while (tail->next->next != NULL)//{//	tail = tail->next;//}//free(tail->next);//tail->next = NULL;}
}
void STLPopFront(STLNode** pphead)
{//检查assert(*pphead != NULL);//if (*pphead == NULL)//{//	return;//}STLNode* first = *pphead;*pphead = first->next;free(first);first = NULL;
}STLNode* STLFind(STLNode* pphead, SLTDataType x)
{STLNode* cur = pphead;while (cur != NULL){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}
void STLInsertFront(STLNode** pphead, STLNode* pos, SLTDataType x)
{//不能实现尾插assert(pos);assert(pphead);if (pos == *pphead){STLPushFront(pphead, x);}else{//找到pos的前一个位置STLNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}STLNode* newnode = BuySTLNode(x);prev->next = newnode;newnode->next = pos;}
}void STLErase(STLNode** pphead, STLNode* pos)
{assert(pphead);assert(pos);assert(*pphead);if (*pphead == pos){STLPopBack(pphead);}else{STLNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);pos = NULL;//可以不写,因为pos为形参}
}
//pos后面插入
void STLInsertAfter(STLNode* pos, SLTDataType x)
{assert(pos);STLNode* newnode = BuySTLNode(x);newnode->next = pos->next;pos->next = newnode;//错误,原因是找不到pos->next//pos->next = newnode;//newnode->next = pos->next;
}
//假设有一个链表,只给出pos,让在前面插入,如何实现
//可以先在后面插入,然后交换//pos位置后面删除
void STLEraseAfter(STLNode* pos)
{assert(pos);assert(pos->next);//方法1//STLNode * del = pos->next;//pos->next = pos->next->next;//free(del);//del = NULL;//方法2STLNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}
void STLDestory(STLNode** pphead)
{assert(pphead);STLNode* cur = *pphead;while (cur){//逐个释放结点STLNode* next = cur->next;free(cur);cur = next;}*pphead = NULL;
}void STLMiddlePos(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead, int num)
{int x = 0;int y = 0;STLPrint(*pphead);if (num == 6){printf("请输入你想要插入的数字:>\n");scanf("%d", &x);printf("请输入你想要插入哪个数字的前面:>\n");scanf("%d", &y);STLNode* ret = STLFind(*pphead, y);STLInsertFront(pphead, ret, x);}else if (num == 7){printf("请输入你想要删除哪个数字:>\n");scanf("%d", &x);STLNode* ret = STLFind(*pphead, x);STLErase(pphead, ret);}else if (num == 8){printf("请输入你想要插入的数字:>\n");scanf("%d", &x);printf("请输入你想要插入哪个数字的后面:>\n");scanf("%d", &y);STLNode* ret = STLFind(*pphead, y);STLInsertAfter(ret, x);}else{printf("请输入你想要删除哪个数字后面的数字:>\n");scanf("%d", &x);STLNode* ret = STLFind(*pphead, x);STLEraseAfter(ret);}STLPrint(*pphead);
}void STLMiddlePush(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead)
{int x = 0;printf("请输入你想要插入的数字:>\n");scanf("%d", &x);pf(pphead, x);STLPrint(*pphead);
}void STLLoadSList(STLNode** pphead)
{FILE* pf = fopen("SList.txt", "r");if (pf == NULL){perror("STLLoadSList");return;}STLNode* cur = *pphead;SLTDataType data = 0;while (fscanf(pf, "%d", &data) == 1){STLPushBack(pphead, data);}fclose(pf);pf = NULL;
}
void STLSaveSList(STLNode** pphead)
{FILE* pf = fopen("SList.txt", "w");if (pf == NULL){perror("STLSaveSList");return;}STLNode* cur = *pphead;while (cur){fprintf(pf, "%d ", cur->data);cur = cur->next;}fclose(pf);pf = NULL;printf("保存文件成功\n");
}

单链表的功能说明

代码效果展示

菜单展示

每次循环开始时会显示菜单，内容包括：
STLExit：退出程序并将单链表保存到文件中
STLPrint：输出
STLPushBack：尾插
STLPopBack：尾删
STLPushFront：头插
STLPopFront：头删
STLFrontInsert：从一个数的前面插入
STLErase：擦除某个指定的数
STLInsertAfter：从一个数的后面插入
STLEraseAfter：删除指定数的后面的数字

在这里插入图片描述

退出单链表（STLExit）

输入 0 后，程序会将单链表中的信息保存到文件 “SList.txt” 中。释放内存并销毁顺序表，然后退出程序。

在这里插入图片描述

输出单链表（STLPrint）

输入 1 后，程序会在屏幕上显示目前已经保存的单链表。

在这里插入图片描述

尾插（STLPushBack）

输入 2 后，程序会提示用户输入插入的数字。输入完成后，数字被添加到单链表的末尾，然后输出修改后的单链表。

在这里插入图片描述

尾删（STLPopBack）

输入 3 后，单链表的末尾的一个数字会被删除，然后输出修改后的单链表。

在这里插入图片描述

头插（STLPushFront）

输入 4 后，程序会提示用户输入插入的数字。输入完成后，数字被添加到单链表的第一个位置，然后输出修改后的单链表。

在这里插入图片描述

头删（STLPopFront）

输入 5 后，单链表的第一个位置的数字会被删除并输出删除后的单链表，然后输出修改后的单链表。

在这里插入图片描述

从某一个数字的前面插入（STLInsertFront）

输入 6 后，程序首先输出单链表，然后会提示用户输入插入的数字和要插入数字的位置。输入完成后，数字被添加到单链表的要输入数字的前面，然后输出修改后的单链表。

在这里插入图片描述

删除指定的数字（STLErase）

输入 7 后，程序会提示用户输入想要删除的数字。输入完成后，想要删除的数字会被清除，然后输出修改后的单链表。

在这里插入图片描述

从某一个数字的后面插入（STLInsertAfter）

输入 8 后，程序首先输出单链表，然后提示用户输入插入的数字和要插入数字的位置。输入完成后，数字被添加到单链表的要输入数字的后面，然后输出修改后的单链表。

在这里插入图片描述

删除指定数字后面的数字（STLEraseAfter）

输入 9 后，程序首先输出单链表，然后提示用户输入要删除的数字。输入完成后，要删除数字后面的数字会被删除，然后输出修改后的单链表。

在这里插入图片描述

代码详解

SList.h

#pragma once

#pragma once 是一个预处理指令，用于防止头文件被重复包含。在大型项目中，多个源文件可能会包含同一个头文件，使用 #pragma once 可以确保头文件的内容只被编译一次，避免重复定义的错误。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include 指令用于引入必要的标准库头文件：

stdio.h：提供标准输入输出函数，如 printf、scanf 等。
assert.h：提供 assert 宏，用于在运行时检查程序的断言条件。
stdlib.h：提供内存管理函数（如 malloc、realloc、free）和其他标准库函数。

typedef int SLTDataType;

#define 指令用于定义一些常量：

typedef int SLTDataType：将 int 重新命名成 SLTDataType

typedef int SLTDataType;
typedef struct SListNode
{SLTDataType data; //数据域,存储节点数据struct SListNode* next;//指针域,指向下一个节点
}STLNode;

定义了一个名为 SListNode 的结构体并重新命名为 STLNode，用于表示整个单链表：

next：指向同类型结构体的指针，用于连接链表中的节点。每个节点通过 next 指向下一个节点，最后一个节点的 next 通常置为 NULL（表示链表结束）。

data：整数，记录当前单链表中的节点数据。

注意
1、必须使用 struct 结构体名* 声明指针域，如 struct SListNode* next;。
2、不能直接使用 typedef 后的别名 STLNode* next;因为 typedef 是在结构体声明之后才生效。

//创建结点并将值填入数据域中
STLNode* BuySTLNode(SLTDataType x);//输出
void STLPrint(STLNode* phead);//尾插
void STLPushBack(STLNode** phead, SLTDataType x);//头插
void STLPushFront(STLNode** pphead, SLTDataType x);//尾删
void STLPopBack(STLNode** phead);//头删
void STLPopFront(STLNode** pphead);//单链表查找
STLNode* STLFind(STLNode* pphead, SLTDataType x);//pos之前插入
void STLInsertFront(STLNode** pphead, STLNode* pos, SLTDataType x);//pos位置删除
void STLErase(STLNode** pphead, STLNode* pos);//pos后面插入
void STLInsertAfter(STLNode* pos, SLTDataType x);//pos位置后面删除
void STLEraseAfter(STLNode* pos);//链表销毁
void STLDestory(STLNode** pphead);//函数指针
void STLMiddlePos(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead, int num);void STLMiddlePush(int(*pf)(STLNode** pphead, SLTDataType x), STLNode** pphead);//从文件中加载
void STLLoadSList(STLNode** pphead);//将链表保存到文件
void STLSaveSList(STLNode** pphead);

函数声明，定义了对单链表进行操作的各个功能函数：
BuySTLNode：动态分配内存创建 1 个新节点，初始化数据域为 x，指针域为 NULL。主要用于插入节点时调用。
STLPrint：遍历链表并输出每个节点的数据，格式为数据 -> 数据 -> NULL。
STLPushBack：在链表尾部插入新节点，数据为 x。
STLPushFront：在链表头部插入新节点，数据为 x。
STLPopBack：删除链表尾部节点。
STLPopFront：删除链表头部节点。
STLFind：遍历链表查找数据为 x 的节点。
STLInsertFront：在目标节点 pos 之前插入新节点，数据为 x。
STLErase：用于从顺序表中删除指定的数字。
STLInsertAfter：在目标节点 pos 之后插入新节点，数据为 x。
STLEraseAfter：删除目标节点 pos 的后继节点。
STLDestory：释放链表所有节点内存，并将头指针置为 NULL。
STLMiddlePos：通过函数指针动态调用插入 / 删除函数，处理用户输入的位置操作。
STLMiddlePush：通过函数指针动态调用插入函数，处理用户输入的插入值。
STLLoadSList：从文件中读取数据，通过尾插法构建链表。
STLSaveSList：将链表数据写入文件。

SList.c

遍历与打印（STLPrint）

void STLPrint(STLNode* phead)
{//空的顺序表可以打印,只是数据为空//assert(phead);//不能STLNode* cur = phead;//while(cur)while (cur != NULL)//cur->next != NULL最后一个数据没有输出,不能写{printf("%d->", cur->data);cur = cur->next;//cur的地址不断覆盖,不能++,不能保证空间是连续的//一块空间的初始地址和结束地址不一样,一块空间的结束地址和下一块空间的起始地址一样}printf("NULL\n");
}

注意

1、允许空链表（直接输出 NULL），这里不能断言，如果断言程序会报错。不需要断言头指针 phead 非空的原因是：允许空链表作为合法输入，如果链表为空则输出 NULL。循环条件 cur != NULL 确保不会访问空指针，即使 phead 为 NULL 也不会引发错误。而顺序表需要断言是为了检查指针的有效性，在空的顺序表中可能存在野指针，头指针 phead 是野指针（未初始化或指向已释放的内存），直接解引用 *phead 会触发未定义行为。
2、使用 cur != NULL 而非 cur->next != NULL，避免遗漏最后一个节点。
3、使用 cur = cur->next; 而不使用 ++ 的原因是指针的算术运算仅适用于连续内存的场景，此时相邻元素的地址差是固定的（等于单个元素的大小）。单链表的节点地址是动态分配的，相邻节点的地址差不确定，无法通过固定偏移量访问。只能通过节点的 next 指针获取后继节点的地址，即 cur = cur->next;

总结

顺序表
1、顺序表的指针失效风险更高
顺序表的表头指针直接指向内存块，若指针无效（如 NULL 或野指针），第一步访问就会崩溃。
2、顺序表的遍历方式不依赖后续指针
顺序表通过下标或偏移量遍历，无需检查每个元素的 “下一个指针” 是否有效，因此指针有效性是遍历的前提，必须在开头断言。

单链表
1、单链表的节点通过指针链接，节点在内存中非连续存储，每个节点包含数据域和指向下一节点的指针 next。
2、表头指针可能为 NULL（空链表），此时直接返回即可，无需访问内存。

节点创建与初始化（BuySTLNode）

STLNode* BuySTLNode(SLTDataType x)
{STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));if (newnode == NULL){perror("SLPushBack");return NULL;}newnode->data = x;newnode->next = NULL;return newnode;
}

作用：动态分配内存并初始化新节点，返回节点指针。
内存安全：malloc 后检查 NULL，防止内存分配失败导致程序崩溃。

尾插

void STLPushBack(STLNode** pphead, SLTDataType x)
{assert(pphead);//*pphead为地址一定不为空,值可以为空STLNode* newnode = BuySTLNode(x);if (*pphead == NULL){*pphead = newnode;}else{//找尾---尾结点STLNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;//错误---头结点//while (tail != NULL)//{//	tail = tail->next;//}//tail = newnode;}
}

1、使用二级指针的原因是因为单链表的头指针本质是一个指针变量，单链表的头指针为 STLNode* plist，它存储的是链表第一个节点的地址，函数内部对 plist 的修改不会影响实参 pphead。当函数参数为二级指针
STLNode** pphead 时，pphead 指向实参 plist 的地址。通过解引用可以访问并修改实参 plist 的值。
2、在尾插时应先创建节点然后遍历单链表将节点链接起来。

头插

void STLPushFront(STLNode** pphead, SLTDataType x)
{assert(pphead);STLNode* newnode = BuySTLNode(x);newnode->next = *pphead;*pphead = newnode;
}

头插时应首先创建新节点，然后新节点的 next 指向原头节点最后更新头指针为新节点地址。

尾删

void STLPopBack(STLNode** pphead)
{//必须有数据才能删除//检查assert(pphead);assert(*pphead);//if (*pphead == NULL)//{//	return;//}//只有一个节点//有多个节点if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}else{//方法1//找尾STLNode* prev = NULL;STLNode* tail = *pphead;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);tail = NULL;//tail是局部变量prev->next = NULL;//方法2//STLNode* tail = *pphead;//while (tail->next->next != NULL)//{//	tail = tail->next;//}//free(tail->next);//tail->next = NULL;}
}

该函数通过二级指针操作链表，在确保链表非空的前提下，通过遍历找到尾节点及其前驱，释放尾节点并正确更新指针，实现单链表的尾删操作。

头删

void STLPopFront(STLNode** pphead)
{//检查assert(*pphead != NULL);//if (*pphead == NULL)//{//	return;//}STLNode* first = *pphead;*pphead = first->next;free(first);first = NULL;
}

该函数通过二级指针确保链表非空后，将头指针更新为原头节点的下一个节点，并释放原头节点内存，实现单链表的头删操作。

查找数字

STLNode* STLFind(STLNode* pphead, SLTDataType x)
{STLNode* cur = pphead;while (cur != NULL){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}

该函数遍历链表，若找到数据域等于 x 的节点则返回其地址，否则返回 NULL，实现单链表的查找操作。

指定数字的后（前）面插入

void STLInsertFront(STLNode** pphead, STLNode* pos, SLTDataType x)
{//不能实现尾插assert(pos);assert(pphead);if (pos == *pphead){STLPushFront(pphead, x);}else{//找到pos的前一个位置STLNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}STLNode* newnode = BuySTLNode(x);prev->next = newnode;newnode->next = pos;}
}
void STLInsertAfter(STLNode* pos, SLTDataType x)
{assert(pos);STLNode* newnode = BuySTLNode(x);newnode->next = pos->next;pos->next = newnode;//错误,原因是找不到pos->next//pos->next = newnode;//newnode->next = pos->next;
}

STLInsertFront 函数在给定节点 pos 前插入新节点（若 pos 是头节点则调用头插法），需通过二级指针修改头指针；STLInsertAfter 函数在给定节点 pos 后插入新节点，直接操作 pos 的 next 指针，无需二级指针。

删除指定位置后面的数字

void STLEraseAfter(STLNode* pos)
{assert(pos);assert(pos->next);//方法1//STLNode * del = pos->next;//pos->next = pos->next->next;//free(del);//del = NULL;//方法2STLNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}

通过断言确保给定节点 pos 及其后继节点存在，删除 pos 的后继节点并释放其内存，实现单链表的指定位置后删除操作。

数据持久化

void STLLoadSList(STLNode** pphead)
{FILE* pf = fopen("SList.txt", "r");if (pf == NULL){perror("STLLoadSList");return;}STLNode* cur = *pphead;SLTDataType data = 0;while (fscanf(pf, "%d", &data) == 1){STLPushBack(pphead, data);}fclose(pf);pf = NULL;
}
void STLSaveSList(STLNode** pphead)
{FILE* pf = fopen("SList.txt", "w");if (pf == NULL){perror("STLSaveSList");return;}STLNode* cur = *pphead;while (cur){fprintf(pf, "%d ", cur->data);cur = cur->next;}fclose(pf);pf = NULL;printf("保存文件成功\n");
}

这两个函数实现了单链表的文件读写功能，STLLoadSList 从文件 SList.txt 读取整数数据，通过尾插法构建链表；STLSaveSList 将链表中的数据写入SList.txt，格式为空格分隔的整数序列。两者均包含完整的文件操作错误处理，确保内存安全和文件资源释放。

test.c

菜单界面

void menu()
{printf("****************************************************\n");printf("*****   0. STLExit          1. STLPrint        *****\n");printf("*****   2. STLPushBack      3. STLPopBack      *****\n");printf("*****   4. STLPushFront     5. STLPopFront     *****\n");printf("*****   6. STLInsertFront   7. STLErase        *****\n");printf("*****   8. STLInsertAfter   9. STLEraseAfter   *****\n");printf("****************************************************\n");
}

使用星号 (*) 绘制边框，提供清晰的视觉界面。
数字编号对应不同功能，方便用户选择。

主循环逻辑

void test()
{int input = 0;STLNode* plist = NULL;STLLoadSList(&plist);do{menu();printf("请输入你想要进行的操作:>\n");scanf("%d", &input);switch (input){case 0:STLSaveSList(&plist);STLDestory(&plist);break;case 1:STLPrint(plist);break;case 2:STLMiddlePush(STLPushBack, &plist);break;case 3:STLPopBack(&plist);STLPrint(plist);break;case 4:STLMiddlePush(STLPushFront, &plist);break;case 5:STLPopFront(&plist);STLPrint(plist);break;case 6:STLMiddlePos(STLInsertFront, &plist, 6);break;case 7:STLMiddlePos(STLErase, &plist, 7);break;case 8:STLMiddlePos(STLInsertAfter, &plist, 8);break;case 9:STLMiddlePos(STLEraseAfter, &plist, 9);break;default:printf("无效输入,请重新输入\n");break;}} while (input);
}

循环控制：使用 do-while 确保至少执行一次菜单选择。
选项处理：通过 switch 分支调用不同功能函数。
安全退出：退出前保存数据并释放内存，防止资源泄漏。

程序入口

int main()
{test();return 0;
}

main 函数是程序的入口点，调用 test 函数启动顺序表，最后返回 0 表示程序正常结束。

在这里插入图片描述

总结

至此，关于数据结构单链表的探索暂告一段落，但你的编程征程才刚刚启航。编写代码是与计算机逻辑深度对话，过程中虽会在结构设计、算法实现的困境里挣扎，但这些磨砺加深了对代码逻辑和数据组织的理解。愿你合上电脑后，灵感不断，在数据结构的世界里持续深耕，书写属于自己的编程传奇，下一次开启，定有全新的精彩等待。小编期待重逢，盼下次阅读时见证你们更大的进步，共赴代码之约！