前言

什么是单链表？

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

链表的创建

需要创建一个小项目工程
创建三个文件
⭐SListNode.h放单链表的头文件，函数声明
⭐SListNode.c放单链表的函数
⭐test.c是主函数，存放框架，测试函数

(1)创建一个链表

首先，我们可以类比顺序表，在创建顺序表的时候，是用一个结构体来创建的,所以我们可以用结构体创建，包括数据和下一个结构体的地址(用来找到下一个地址)

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLT;

为什们用动态开辟？

首先我们知道局部变量出了作用域，就自己消除了，如果我们在一个函数中自己申请空间用来创建结构体，如果我们出了这个函数，我们就找不到这个链表，但是如果用动态空间，所开辟的空间在堆上存放，即便我们出了作用域，我们都来能找到这个链表，这就是我们动态开辟的原因。

(2)动态开辟单个链表

我们上面创建一个链表，只是创建了一个结构体，只是每一个链表中的元素有什们，而我们这个是给链表装东西，将链表的内容填充了。

//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc");exit(-1);}newnode->data = n;newnode->next = NULL;
}

(3)创建n个链表

我们开辟完单个链表，链表的内容都有了，但是这个链表只有一个，我们要创建的链表不是只有一个，是需要我们将他们都串起来。所以我们下一步就是创建n个链表。具体的注意事项，我们都放在了代码的注释当中。

//创建n个链表
SLTNode* CreatSLT(int n)
{//这是为了省事，直接用循环创建n个单个链表int i = 0;//头指针是不能动的，因为最后返回的是链表的头指针//所以我们设置一个尾指针，先和头指针相同，移动的//时候移动尾指针就好了。SLTNode* phead = NULL;SLTNode* ptail = NULL;for (i = 0; i < n; i++){SLTNode* newnode = BuySLTNode(i);//如果头指针是空指针，//那么先将头指针和尾指针还有新创建的单个链表设为相等if (phead == NULL){phead = ptail = newnode;}else{ptail->next = newnode;ptail = newnode;}}return phead;
}

(4)打印链表

我们上面创建了链表，我们为了显示我们的链表，我们就要打印链表，进而显示我们链表，我们怎么打印链表，就仔细看代码就可以了，大家多看看注释，这很重要。

//打印链表
void PrintSLT(SLTNode* phead)
{//我们想一想，如果链表为空可不可以打印//很显然是可以的，我们打印一个空指针就很OK//所以我们不对他进行断言//我们一般不动我们的头指针，//所以我们要找一个东西代替他SLTNode* cur = phead;//我们打印肯定需要循环，是循环就需要条件，//我们循环的条件就是//直到我们遇到最后一个链表的next了，也就是空指针的时候while (cur ！= NULL){printf("%d->", cur->data);cur = cur->next;}//因为最后一个肯定是空指针//为了打印的美观，我们打印一个空指针printf("NULL");}

(5)单链表的尾插

现在我们将一个简易的链表做了出来，我们要实现链表的功能。
首先实现尾插的功能，但是有很多注意的事项，我们先看两段有点问题的代码，首先先自己想一下问题是什们，然后自己再看答案，我们只要解决了这个问题我们的功能基本上就解决了

问题一

//单链表尾插
void SLTPushBack(SLTNode* phead, SLDataType n)
{SLTNode* newnode = BuySLTNode(n);SLTNode* tail = phead;while (tail){tail = tail->next;}tail = newnode;
}

其实这个问题还是比较容易发现的，只要我们画个图，我们就能发现这个条件其实是有问题的，当tail结束循环的时候tail等于NULL，而让我们新创建的链表等于空指针，没有任何作用。所以这个条件有问题。
其实这个问题还是很简单的，还有一个问题才是重点。我们先修改这个代码

问题二

//单链表尾插
void SLTPushBack(SLTNode* phead,SLTDataType n)
{SLTNode* newnode = BuySLTNode(n);SLTNode* tail = phead;while (tail->next){tail = tail->next;}tail->next= newnode;
}

现在我们将循环的条件改变了，当tail的next等于空指针，我们在将tail的next赋值位新链表的地址我们就很好的修改了。

但是如果我们的链表为空的时候，我们能不能在尾插内容呢？
答案显而易见，当然是可以的，但是这时tail是NULL,我们在进行这个条件的时候tail->next，这时就发生了空指针的解引用。

这时候有的同学就说，我们可以用if条件区别一下空指针就可以了呀。我们先看代码。和调试。

//单链表尾插
void SLTPushBack(SLTNode* phead,SLDataType n)
{SLTNode* newnode = BuySLTNode(n);SLTNode* tail = phead;if (phead == NULL){tail = phead = newnode;}else{while (tail->next){tail = tail->next;}tail->next = newnode;}
}

我们发现在我们进行测试的时候，我们开头是空指针的时候，并没有尾插上，到底是什们原因呢？

我们知道，形参的改变并不会影响实参。我们在进行尾插的时候，传的是一级指针，在我们的函数调用中phead是NULL，在if条件下将phead赋值为newnode,但是再出了这个函数后，我们的phead还是NULL，并不会改变，因为，形参的改变并不会影响实参。

如果我们不理解，可以不要将phead想象成一个指针，就把他当作一个整型，在函数中，我们改变他，只是在函数的作用域中有用，一旦出了这个作用域，那么改变的量就不会起作用，他是多少就是多少，如果想在函数中改变他的值，我们就需要传该数的指针，通过改变指针的方式，才能改变该数的实参。

所以我们想要改变phead，我们需要通过phead的指针来改变phead也就要用到二级指针。

//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{SLTNode* newnode = BuySLTNode(n);if (*pphead == NULL){*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next){tail = tail->next;}tail->next = newnode;}
}

(6)单链表的尾删

单链表尾删，我们就是将最后一个链表的上一个链表的next设置为NULL
怎么找最后一个链表的上一个链表，具体操作看代码注释。

//单链表尾删
void SLTPopBack(SLTNode* phead)
{//我们在移动的时候一般不移动phead//所以我们一般都使用另一个来代替pheadSLTNode* tail = phead;//因为我们要将tail的前面的链表找到所以//创建一个prevSLTNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);//将prev的next滞空，就相当于删除了prev->next = NULL;
}

这个其实也是有问题的，我们如果只剩下一个结点，我们要找tail前一个结点就没有，所以我们这个需要分类讨论。
请看下面代码

//单链表尾删
void SLTPopBack(SLTNode* phead)
{//我们只有一个结点，分类讨论if (phead->next == NULL){free(phead);//和上面一样的问题phead = NULL;}else{//我们在移动的时候一般不移动phead//所以我们一般都使用另一个来代替pheadSLTNode* tail = phead;//因为我们要将tail的前面的链表找到所以//创建一个prevSLTNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);//将prev的next滞空，就相当于删除了prev->next = NULL;}}

我们其实还有问题，在注释上也写到了，我们形参的改变不影响实参的改变，并不能将phead变为空指针，所以我们还是要用二级指针。

//单链表尾删
void SLTPopBack(SLTNode** pphead)
{//如果链表为空，我们就不能再删了//需要断言assert(*pphead);//我们只有一个结点，分类讨论if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}else{//我们在移动的时候一般不移动phead//所以我们一般都使用另一个来代替pheadSLTNode* tail = *pphead;//因为我们要将tail的前面的链表找到所以//创建一个prevSLTNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);//将prev的next滞空，就相当于删除了prev->next = NULL;}
}

(7)单链表的头插

其实我们的单链表的头插和头删，还是要用二级指针。
头插其实很简单，就是先创建一个结点，然后将结点的next赋值为第一个节点的地址，就可以了。

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{SLTNode* newnode = BuySLTNode(n);newnode->next = *pphead;//头插完，将插完的第一个设为头结点*pphead = newnode;
}

(8)单链表的头删

头删就是将头结点放到下一个结点就行

//单链表头删
void SLTPopFront(SLTNode** pphead)
{//防止空指针的解引用assert(*pphead);SLTNode* next = (*pphead)->next;free(*pphead);*pphead = next;
}

(9)链表的查找

因为我们后面要进行，在链表的中间进行添加和删除，我们就是需要，先找到我们需要在哪里添加和删除，我们就要进行查找。因为查找我们不需要进行修改头指针，所以我们就不需要用二级指针。用一级指针就可以了。
我们知道了为什们查找，所以我们就看下面的代码吧。

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{SLTNode* cur = phead;while (cur){if (cur->data == n)return cur;elsecur = cur->next;}return NULL;
}

(10)在pos后插入

我们先用查找函数，找到我们要插入的位置，也就是pos,然后我们再将需要插入的东西插入就可以了。

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{assert(pos);SLTNode* newnode = BuySLTNode(n);newnode->next = pos->next;pos->next = newnode;
}

(11)在pos前插入

其实是一样的道理，但是我们需要找到pos前的结点，我们就需要从头开始寻找，找到pos前的结点，然后在进行改变。
但是如果我们在第一个结点前插入，我们就变成了头插，我们就需要改变头指针，所以我们就要用二级指针。

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{assert(pos);if (*pphead == pos){SLTPushFront(pphead, n);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}SLTNode* newnode = BuySLTNode(n);cur->next = newnode;newnode->next = pos;}
}

(12)删除pos之后的结点

这个非常简单，我们直接看代码，注释有解释。

//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{assert(pos);//如果pos是最后一个，那么我们还删什们//就直接返回就行，不删除if (pos->next == NULL){return;}else{SLTNode* nextNode = pos->next;pos->next = nextNode->next;free(nextNode);//nextNode = NULL;}
}

(13)删除pos位置的结点

这个类比就行了，直接看代码，非常简单的。我们删除还可能是头删，所以我们还是用二级指针。注释解释

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pos);//就是头删就直接调用就可以了if (*pphead == NULL){SLTPopFront(pphead);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}cur->next = pos->next;free(pos);}
}

(14)单链表的释放

就是动态开放完，然后再用free释放。直接上代码

//单链表的释放
void SLTDestroy(SLTNode** pphead)
{SLTNode* cur = *pphead;//循环一个一个释放while (cur){SLTNode* next = cur->next;free(cur);cur = next;}
}

总结

其实对于我们的单链表，我们就基本上讲完了，其中最关键的问题，也是最难的问题就是我们要理解为什们要用二级指针。只要理解了这一点，我相信大家一定可以钻研明白。

还有一个问题就是，我们对于在主函数，就不进行包装了，我们自己测试就可以了，我们最后将函数的声明和实现给大家。
希望大家一起进步一起加油！！！！！

SListNode.h代码

#pragma once
#include
#include
#include
typedef int SLDataType;//创建一个单链表
typedef struct SListNode
{SLDataType data;struct SListNode* next;
}SLTNode;//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n);//创建n个链表
SLTNode* CreatSLT(int n);//打印链表
void PrintSLT(SLTNode* phead);//链表的尾插
void SLTPushBack(SLTNode** pphead, SLDataType n);//单链表尾删
void SLTPopBack(SLTNode** pphead);//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n);//单链表头删
void SLTPopFront(SLTNode** pphead);//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n);//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n);//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n);//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);//单链表的释放
void SLTDestroy(SLTNode** pphead);

SListNode.c代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListNode.h"//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc");exit(-1);}newnode->data = n;newnode->next = NULL;return newnode;
}//创建n个链表
SLTNode* CreatSLT(int n)
{//这是为了省事，直接用循环创建n个单个链表int i = 0;//头指针是不能动的，因为最后返回的是链表的头指针//所以我们设置一个尾指针，先和头指针相同，移动的//时候移动尾指针就好了。SLTNode* phead = NULL;SLTNode* ptail = NULL;for (i = 1; i <= n; i++){SLTNode* newnode = BuySLTNode(i);//如果头指针是空指针，//那么先将头指针和尾指针还有新创建的单个链表设为相等if (phead == NULL){phead = ptail = newnode;}else{ptail->next = newnode;ptail = newnode;}}return phead;
}//打印链表
void PrintSLT(SLTNode* phead)
{//我们想一想，如果链表为空可不可以打印//很显然是可以的，我们打印一个空指针就很OK//所以我们不对他进行断言//我们一般不动我们的头指针，//所以我们要找一个东西代替他SLTNode* cur = phead;//我们打印肯定需要循环，是循环就需要条件，//我们循环的条件就是//直到我们遇到最后一个链表的next了，也就是空指针的时候while (cur != NULL){printf("%d -> ", cur->data);cur = cur->next;}//因为最后一个肯定是空指针//为了打印的美观，我们打印一个空指针printf("NULL\n");}//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{SLTNode* newnode = BuySLTNode(n);if (*pphead == NULL){*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next){tail = tail->next;}tail->next = newnode;}
}
//单链表尾删
void SLTPopBack(SLTNode** pphead)
{//如果链表为空，我们就不能再删了//需要断言assert(*pphead);//我们只有一个结点，分类讨论if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}else{//我们在移动的时候一般不移动phead//所以我们一般都使用另一个来代替pheadSLTNode* tail = *pphead;//因为我们要将tail的前面的链表找到所以//创建一个prevSLTNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);//将prev的next滞空，就相当于删除了prev->next = NULL;}}
//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{SLTNode* newnode = BuySLTNode(n);newnode->next = *pphead;//头插完，将插完的第一个设为头结点*pphead = newnode;
}//单链表头删
void SLTPopFront(SLTNode** pphead)
{//防止空指针的解引用assert(*pphead);SLTNode* next = (*pphead)->next;free(*pphead);*pphead = next;
}//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{SLTNode* cur = phead;while (cur){if (cur->data == n)return cur;elsecur = cur->next;}return NULL;
}//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{assert(pos);SLTNode* newnode = BuySLTNode(n);newnode->next = pos->next;pos->next = newnode;
}//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{assert(pos);if (*pphead == pos){SLTPushFront(pphead, n);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}SLTNode* newnode = BuySLTNode(n);cur->next = newnode;newnode->next = pos;}
}//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{assert(pos);//如果pos是最后一个，那么我们还删什们//就直接返回就行，不删除if (pos->next == NULL){return;}else{SLTNode* nextNode = pos->next;pos->next = nextNode->next;free(nextNode);//nextNode = NULL;}
}
//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pos);//就是头删就直接调用就可以了if (*pphead == NULL){SLTPopFront(pphead);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}cur->next = pos->next;free(pos);}
}//单链表的释放
void SLTDestroy(SLTNode** pphead)
{SLTNode* cur = *pphead;//循环一个一个释放while (cur){SLTNode* next = cur->next;free(cur);cur = next;}
}