前言
在上一节中我们提到了顺序表有如下缺陷：
在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；
增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的消耗；
增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；
基于顺序表的这些不足，我们设计出了链表。
一、链表
1、链表的概念及结构
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
链表和顺序表的不同之处在于：顺序表不仅要求逻辑结构上也连续，还要求物理结构上连续；而链表只要求逻辑结构上连续，物理结构上可以不连续；
所谓的逻辑结构指的是数据在逻辑上是如何存储的，这是由人们主观想象出来的；而物理结构则是数据在物理内存中实际存储的方式，不随人们的主观意志而改变。
链表的结构图示如下：
从上面的图中我们也可以看出：链表在逻辑结构上连续指的是链表的每一个节点都记录着下一个节点的地址，我们可以根据此地址来找到链表的下一个节点，就好像它们被一根线连起来了一样；
而实际上链表的每一个节点都是在堆区上随机申请的，前一个节点的地址可能比后一个节点大，也可能比后一个节点小，二者之前其实并没有物理结构上的关系。
2、链表的分类
在实际应用中，链表根据带头/不带头、循环/不循环、双向/单向这三种选择一共可以组合出8种结构。
单向或者双向：双向链表对比单向链表来说，其结构体中会多一个结构体指针变量，用来指向前一个节点的地址。
带头或者不带头：带头与不带头其实区别就是链表最开始的时候会有一个节点，这个节点不用来存储数据，仅仅作为链表的头部使用，还是一个节点都没有。
循环或者非循环：非循环链表的最后一个节点的next指向NULL，而循环链表的最后一个节点的next指向链表的第一个节点。
3、最常用的两种链表
虽然链表有这么多中结构，但是我们实际中最常用还是以下两种结构：无头单向非循环链表和双向带头循环链表。
无头单向非循环链表
无头单向非循环链表结构最简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等；另外这种结构在笔试面试中出现很多；其实如果不做特殊声明，一般情况下无头单向非循环链表指的就是我们的单链表；
带头双向循环链表
带头双向循环链表结构最复杂，一般用于单独存储数据；实际中我们使用的链表数据结构，都是带头双向循环链表；另外它虽然结构复杂，但是使用代码实现后会有很多优势，所以反而是链表中使用起来最简单的。
二、单链表的实现
由于单链表是其他结构链表学习的基础，且经常被用做其他数据结构的子结构，在笔试题中也最常被考到，所以下面我们用C原因来手动实现一个单链表，以此来加强我们对单链表的理解。
1、结构的定义
实现，与顺序表一样，单链表也需要一个变量来data来记录数据，且我们应该对data的类型重命名，使得我们的链表可以管理不同类型的数据；其次，由于单链表中需要存储下一个节点的地址，所以我们应该有一个指向结构体的指针。
//符号和结构的声明
typedef int SLTDataType; //数据类型重命名
typedef struct SListNode //链表的一个节点
{
SLTDataType data;
struct SListNode* next; //存放下一个节点的地址
}SLTNode;
2、创建新节点
由于单链表的每一个节点都需要单独开辟，所以我们可以把创建节点封装成一个函数，避免在头插、尾插、任意位置插入这些位置重复实现。
需要注意的是，由于我们这里实现的单链表是不带头的，即单链表一开始就是空的，所以我们并不需要对其进行初始化操作，只需要定义一个指向NULL的节点指针 plist 即可。
//创建新节点
SLTNode* BuySLTNode(SLTDataType x)
{
SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
if (newNode == NULL)
{
perror("malloc fail");
return NULL; //如果malloc失败，返回NULL
}
newNode->data = x;
newNode->next = NULL;
return newNode;
}
3、在头部插入数据
特别注意：不管我们在什么地方插入数据，我们都需要传递二级指针，因为链表一开始是空的，所以我们在插入第一个数据的时候需要让 plist 指向我们新开辟的这一个节点，即头结点；而我们知道，要改变 int，需要传递 int*，要改变 int*，需要传递 int**，类比过来，这里的 plist 是一个结构体指针变量，我们想要改变它，让它从 NULL 变为第一个节点的地址，就需要传递结构体指针的地址，即二级指针才能实现。
其次，我们在改变节点中的next指针的时候使用的是结构体指针，即一级指针，而并没有用到二级指针，这是因为我们修改节点中的next是对结构体进行操作，而要改变结构体我们只需要使用结构体指针即可，而不用像上面修改结构体指针一样使用二级指针。
同时，结构体指针的地址是一定不为空的，因为即使是链表为空即 plis == NULL 的时候，&plist 也不等于空，所以我们需要对 pphead 进行断言，来保证代码的鲁棒性；而链表又是可能为空的，所以我们不需要对 *pphead (即 plist) 进行断言。
如果我们使用带头节点的单链表就不需要传递二级指针，因为不管我们如何对链表进行操作，头结点都始终不会改变。
//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x) //要改变plist，所以用二级指针来接收plist的地址
{
assert(pphead); //pphead为plist的地址，一定不为空
//assert(*pphead); //error：*pphead得到plist，而链表可能没有节点，所以plist可以为空，不用断言
SLTNode* newNode = BuySLTNode(x); //开辟新节点
newNode->next = *pphead;
*pphead = newNode;
}
4、在尾部插入数据
在尾部插入数据我们需要先找到的尾结点的前一个节点，因为我们需要让前一个节点的next指针指向新开辟的节点，然后让新开辟的节点的next指向尾结点，这样才能让我们的链表链接起来。
而我们的单链表只能找到下一个节点的地址，想要找到前一个节点需要从头开始遍历，所以单链表尾插的效率是比较低的，时间复杂度为O(N)，我们可以通过设计双向链表来解决这个问题。
//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead); //plist的地址一定不为空
SLTNode* newNode = BuySLTNode(x);
if (*pphead == NULL) //如果链表为空
{
newNode->next = *pphead;
*pphead = newNode;
return;
}
//如果链表不为空，我们需要找到链表的尾
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newNode;
}
5、查找数据
查找数据不会改变头结点，所以我们只需要传递一级指针。
//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
assert(phead); //链表为空查找直接报错
SLTNode* cur = phead;
while (cur != NULL)
{
if (cur->data == x)
return cur; //找到返回节点地址
cur = cur->next;
}
return NULL; //找不到返回空
}
6、在pos位置前插入数据
和尾插一样，我们需要从头遍历链表，找到 pos 节点的前一个节点，让该节点的next指向新开辟的节点，使得链表成功链接。
//在pos位置前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);
if (pos == *pphead) //如果pos等于*pphead，相当于头插
{
SListPushFront(pphead, x);
return;
}
SLTNode* newNode = BuySLTNode(x);
//找到pos位置的前一个节点
SLTNode* prev = *pphead;
while (prev->next != pos)
{
assert(prev); //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
prev = prev->next;
}
prev->next = newNode;
newNode->next = pos;
}
7、在pos位置后插入数据
由于单链表在某一节点的前面插入数据时需要从头遍历寻找该节点的前一个节点，导致时间复杂度为O(N)，所以人们为了提高单链表的效率，为单链表单独设计了在pos位置后插入数据的函数；除了单链表，其他数据结构插入数据都是在前面插入。
//在pos位置之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead && pos);
SLTNode* next = pos->next;
SLTNode* newNode = BuySLTNode(x);
pos->next = newNode;
newNode->next = next;
}
8、在头部删除数据
特别注意： 和插入数据一样，因为我们删除的可能是链表中的最后一个数据，即可能会改变 plist 的指向 (让 plist 重新指向 NULL)，所以不管我们在什么地方删除数据，都需要传递二级指针。
其次，由于我们这里是删除数据，所以函数调用者需要保证调用此函数时链表中至少是含有一个数据的；所以我们对 *pphead (等价于 plist) 进行断言，当调用者错误使用此函数时，我们直接报错并介绍程序。
//在头部删除数据
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
assert(*pphead); //当链表为空时，删除元素报错
SLTNode* tmp = (*pphead)->next; //注意：* 和 -> 优先级一样，要加括号
free(*pphead);
*pphead = tmp;
}
9、在尾部删除数据
在尾部删除数据面临着和尾插一样的问题，需要改变前一个节点的next指针，所以时间复杂度也为O(N)。
//在尾部删除数据
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
assert(*pphead); //当链表为空时，删除元素报错
if ((*pphead)->next == NULL) //当链表只有一个元素时，相当于头删
{
SListPopFront(pphead);
return;
}
//先找到链表的尾及其前一个节点
SLTNode* cur = *pphead;
SLTNode* prev = cur;
while (cur->next != NULL)
{
prev = cur;
cur = cur->next;
}
prev->next = NULL;
free(cur);
cur = NULL;
}
10、删除pos位置前的数据
//删除pos位置前的数据
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && pos);
assert(*pphead); //当链表为空时，删除元素报错
if (pos == *pphead) //pos等于*pphead时相当于头删
{
SListPopFront(pphead);
return;
}
//找到pos的前一个节点
SLTNode* prev = *pphead;
while (prev->next != pos)
{
assert(prev); //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
prev = prev->next;
}
SLTNode* tmp = pos->next;
prev->next = tmp;
free(pos);
pos = NULL;
}
11、删除pos位置后的数据
和在pos位置后插入数据一样，为了提高效率，人们也设计了一个在pos位置后删除数据的函数。
//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && pos);
assert(*pphead); //当链表为空时，删除元素报错
assert((*pphead)->next); //当链表只有一个元素时，也不能调用此函数
SLTNode* tmp = pos->next->next;
free(pos->next);
pos->next = tmp;
}
12、修改pos位置处的数据
修改数据也不会改变头指针，所以这里传一级指针；同时，为了保证代码的鲁棒性，我们这里对 phead 和 pos 断言一下。
//修改pos位置处的数据
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
assert(phead && pos);
SLTNode* cur = phead;
while (cur != pos)
{
assert(cur); //如果cur为空循环还没停止，说明在链表中找不到pos，直接报错
cur = cur->next;
}
cur->data = x;
}
13、打印链表中的数据
打印数据也不会改变头指针，所以这里传一级指针；但是这里和修改数据不一样的地方是，当链表为空的时候我们打印的逻辑也是正常的，只是说调用此函数什么都不打印而已，但是我们不能对其断言让其为空时报错。
//打印链表
void SListPrint(SLTNode* phead) //打印不需要改变plist
{
//不用对Phead进行断言，当链表为空时打印的逻辑是正常的
SLTNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->data); //-> 和 NULL 是为了让我们的链表更形象化
cur = cur->next;
}
printf("NULL\n");
}
14、销毁链表
销毁链表需要将 plist 值为空，所以这里我们传递二级指针。文章来源：https://www.toymoban.com/news/detail-739393.html
//销毁链表
void SListDestory(SLTNode** pphead)
{
assert(pphead);
SLTNode* cur = *pphead;
while (cur != NULL)
{
SLTNode* tmp = cur->next; //保存下一个节点的地方
free(cur); //释放
cur = tmp;
}
*pphead = NULL; //将plist置为空
}
三、完整代码
1、SList.h
#pragma once //防止头文件重复包含
//头文件的包含
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//符号和结构的声明
typedef int SLTDataType; //数据类型重命名
typedef struct SListNode //链表的一个节点
{
SLTDataType data;
struct SListNode* next; //存放下一个节点的地址
}SLTNode;
//函数的声明
//创建新建节点
SLTNode* BuySLTNode(SLTDataType x);
//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x);
//销毁链表
void SListDestory(SLTNode** pphead);
//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x);
//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos之前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//打印链表
void SListPrint(SLTNode* phead);
//在头部删除数据
void SListPopFront(SLTNode** pphead);
//在尾部删除数据
void SListPopBack(SLTNode** pphead);
//删除pos位置处的数据
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos);
//修改pos位置处的函数
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x);
2、SList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
//创建新节点
SLTNode* BuySLTNode(SLTDataType x)
{
SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
if (newNode == NULL)
{
perror("malloc fail");
return NULL; //如果malloc失败，返回NULL
}
newNode->data = x;
newNode->next = NULL;
return newNode;
}
//销毁链表
void SListDestory(SLTNode** pphead)
{
assert(pphead);
SLTNode* cur = *pphead;
while (cur != NULL)
{
SLTNode* tmp = cur->next; //保存下一个节点的地方
free(cur); //释放
cur = tmp;
}
*pphead = NULL; //将plist置为空
}
//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x) //要改变plist，所以用二级指针来接收plist的地址
{
assert(pphead); //pphead为plist的地址，一定不为空
//assert(*pphead); //error：*pphead得到plist，而链表可能没有节点，所以plist可以为空，不用断言
SLTNode* newNode = BuySLTNode(x); //开辟新节点
newNode->next = *pphead;
*pphead = newNode;
}
//打印链表
void SListPrint(SLTNode* phead) //打印不需要改变plist
{
//不用对Phead进行断言，当链表为空时打印的逻辑是正常的
SLTNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->data); //-> 和 NULL 是为了让我们的链表更形象化
cur = cur->next;
}
printf("NULL\n");
}
//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead); //plist的地址一定不为空
SLTNode* newNode = BuySLTNode(x);
if (*pphead == NULL) //如果链表为空
{
newNode->next = *pphead;
*pphead = newNode;
return;
}
//如果链表不为空，我们需要找到链表的尾
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newNode;
}
//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
assert(phead); //链表为空查找直接报错
SLTNode* cur = phead;
while (cur != NULL)
{
if (cur->data == x)
return cur; //找到返回节点地址
cur = cur->next;
}
return NULL; //找不到返回空
}
//在pos位置前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);
if (pos == *pphead) //如果pos等于*pphead，相当于头插
{
SListPushFront(pphead, x);
return;
}
SLTNode* newNode = BuySLTNode(x);
//找到pos位置的前一个节点
SLTNode* prev = *pphead;
while (prev->next != pos)
{
assert(prev); //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
prev = prev->next;
}
prev->next = newNode;
newNode->next = pos;
}
//在pos位置之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead && pos);
SLTNode* next = pos->next;
SLTNode* newNode = BuySLTNode(x);
pos->next = newNode;
newNode->next = next;
}
//在头部删除数据
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
assert(*pphead); //当链表为空时，删除元素报错
SLTNode* tmp = (*pphead)->next; //注意：* 和 -> 优先级一样，要加括号
free(*pphead);
*pphead = tmp;
}
//在尾部删除数据
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
assert(*pphead); //当链表为空时，删除元素报错
if ((*pphead)->next == NULL) //当链表只有一个元素时，相当于头删
{
SListPopFront(pphead);
return;
}
//先找到链表的尾及其前一个节点
SLTNode* cur = *pphead;
SLTNode* prev = cur;
while (cur->next != NULL)
{
prev = cur;
cur = cur->next;
}
prev->next = NULL;
free(cur);
cur = NULL;
}
//删除pos位置处的数据
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && pos);
assert(*pphead); //当链表为空时，删除元素报错
if (pos == *pphead) //pos等于*pphead时相当于头删
{
SListPopFront(pphead);
return;
}
//找到pos的前一个节点
SLTNode* prev = *pphead;
while (prev->next != pos)
{
assert(prev); //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
prev = prev->next;
}
SLTNode* tmp = pos->next;
prev->next = tmp;
free(pos);
pos = NULL;
}
//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && pos);
assert(*pphead); //当链表为空时，删除元素报错
assert((*pphead)->next); //当链表只有一个元素时，也不能调用此函数
SLTNode* tmp = pos->next->next;
free(pos->next);
pos->next = tmp;
}
//修改pos位置处的数据
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
assert(phead && pos);
SLTNode* cur = phead;
while (cur != pos)
{
assert(cur); //如果cur为空循环还没停止，说明在链表中找不到pos，直接报错
cur = cur->next;
}
cur->data = x;
}
3、test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
void test1() //测试插入
{
SLTNode* plist = NULL; //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；
//头插
SListPushFront(&plist, 1);
SListPushFront(&plist, 2);
SListPushFront(&plist, 3);
SListPrint(plist);
//尾插
SListPushBack(&plist, 4);
SListPushBack(&plist, 5);
SListPushBack(&plist, 6);
SListPrint(plist);
//在pos位置前插入
SLTNode* pos = SListFind(plist, 5);
if (pos != NULL)
{
SListInsert(&plist, pos, 50);
}
pos = SListFind(plist, 3);
if (pos != NULL)
{
SListInsert(&plist, pos, 30);
}
SListPrint(plist);
pos = SListFind(plist, 6);
if (pos != NULL)
{
SListInsert(&plist, pos, 60);
}
SListPrint(plist);
//在pos位置后插入
pos = SListFind(plist, 1);
if (pos != NULL)
{
SListInsertAfter(&plist, pos, 10);
}
pos = SListFind(plist, 3);
if (pos != NULL)
{
SListInsertAfter(&plist, pos, 30);
}
SListPrint(plist);
//销毁
SListDestory(&plist);
}
void test2() //测试删除
{
SLTNode* plist = NULL; //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；
//头插
SListPushFront(&plist, 1);
SListPushFront(&plist, 2);
SListPushFront(&plist, 3);
SListPrint(plist);
//在头部删除数据
//SListPopFront(&plist);
//SListPopFront(&plist);
//SListPopFront(&plist);
//SListPrint(plist);
//在尾部删除数据
//SListPopBack(&plist);
//SListPopBack(&plist);
//SListPopBack(&plist);
//SListPrint(plist);
//删除pos位置处的数据
//SLTNode* pos = SListFind(plist, 1);
//if (pos != NULL)
//{
// SListErase(&plist, pos);
//}
//pos = SListFind(plist, 3);
//if (pos != NULL)
//{
// SListErase(&plist, pos);
//}
//SListPrint(plist);
//pos = SListFind(plist, 2);
//if (pos != NULL)
//{
// SListErase(&plist, pos);
//}
//SListPrint(plist);
//删除pos位置后的数据
SLTNode* pos = SListFind(plist, 2);
if (pos != NULL)
{
SListEraseAfter(&plist, pos);
}
SListPrint(plist);
pos = SListFind(plist, 3);
if (pos != NULL)
{
SListEraseAfter(&plist, pos);
}
SListPrint(plist);
//销毁
SListDestory(&plist);
}
void test3() //测试查和改
{
SLTNode* plist = NULL; //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；
//头插
SListPushFront(&plist, 1);
SListPushFront(&plist, 2);
SListPushFront(&plist, 3);
SListPrint(plist);
//查找并修改pos位置处的数据
SLTNode* pos = SListFind(plist, 3);
if (pos != NULL)
{
SListModify(plist, pos, 30);
}
SListPrint(plist);
pos = SListFind(plist, 1);
if (pos != NULL)
{
SListModify(plist, pos, 10);
}
SListPrint(plist);
//销毁
SListDestory(&plist);
}
int main()
{
//test1(); //测试插入
//test2(); //测试删除
test3(); //测试查和改
}
大家也可以去我的 Gitee 仓库中获取完整代码：SList/SList · 野猪佩奇/日常学习 - 码云 - 开源中国 (gitee.com)文章来源地址https://www.toymoban.com/news/detail-739393.html
到了这里，关于【数据结构】单链表的增删查改（C语言实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![[C语言][数据结构][链表] 单链表的从零实现!](https://imgs.yssmx.com/Uploads/2024/04/847183-1.png)
