【数据结构】— 线性表之「单链表」的实现
꧁ 各位大佬们好！很荣幸能够得到您的访问，让我们一起在编程道路上任重道远！꧂
☙ 博客专栏：【数据结构初阶】❧
⛅ 本篇内容简介：数据结构初阶中线性表之单链表的实现！
⭐ 了解作者：励志成为一名编程大牛的学子，目前正在升大二的编程小白。
✍励志术语：编程道路的乏味，让我们一起学习变得有趣！
文章目录
➜ 顺序表的问题（缺陷）及思考
➤ 链表
➜ 链表的概念及结构
➜ 链表的分类
⟶ 1. 单向或者双向
⟶ 2. 带头或者不带头
⟶ 3. 循环或者非循环
➜ 链表的实现
⟶ 1. 单链表的结构
⟶ 2. 单链表的打印
⟶ 3. 单链表的结点动态申请
⟶ 4. 单链表的尾插
⟶ 5. 单链表的头插
⟶ 6. 单链表的销毁
⟶ 7. 单链表的头删
⟶ 8. 单链表的尾删
⟶ 9. 单链表的查找
⟶ 10. 单链表在pos之前插入
⟶ 11. 单链表在pos之后插入
⟶ 12. 删除pos的位置
⟶ 13. 删除pos之后的位置
➜ 单链表实现所有源代码
⟶ SList.h 头文件
⟶ SList.c 源文件
⟶ Test.c 源文件
➜ 结束语
➜ 顺序表的问题（缺陷）及思考
问题：
1. 中间 / 头部的插入删除，时间复杂度为O(N)。
2. 增容需要申请新空间，拷贝数据，释放旧空间，会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。
例如：当前容量为100，满了以后增容道200，我们再继续插入5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
思考：
如何解决以上的问题呢？下面给出链表的结构来看看。
➤ 链表
➜ 链表的概念及结构
概念：
链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
形象得可以用火车的形式表示：
现实中，数据结构中：
注意：
1. 从上面的图可以看出，链式结构在逻辑上是连续的，但是在物理上不一定是连续的。
2. 现实的结点一般都是从堆上申请出来的。
3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能 不连续。
假设在32位系统上，结点中值域为int类型，则一个结点的大小为8个字节，则也可能有下述链表：
➜ 链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
⟶ 1. 单向或者双向
⟶ 2. 带头或者不带头
⟶ 3. 循环或者非循环
虽然有这么多的链表结构，但是我们实际中最常用的还是两种结构：
1. 无头单向非循环链表：结构简单，一般不会单独用来存放数据，实际中更多是作为其他数据结构的子结构，如：哈希桶，图的邻接表等等，另外这种结构在 笔试面试 出现很多。
2. 带头双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现起来反而更见简单，后面我们代码实现就知道了。
➜ 链表的实现
（无头+单向+非循环链表的 增删查改 的实现）
⟶ 1. 单链表的结构
①. 存放数据。
②. 存放下一个结点的地址。
代码实现：
typedef int SLTDataType;
//结构
typedef struct SListNode
{
SLTDataType Data;
struct SListNode* next;
}SListNode;⟶ 2. 单链表的打印
//单链表的打印
void SListPrint(SListNode* phead);在这里我们一定要结合图形写代码：
注意：这里我们不能加上断言（因为链表可能为空）。
代码实现：
//单链表的打印
void SListPrint(SListNode* phead)
{
SListNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->Data);
cur = cur->next;//cur往后走
}
printf("NULL\n");
}测试打印结果：（此时链表为空，打印NULL）
⟶ 3. 单链表的结点动态申请
//单链表结点的动态申请 返回newnode
SListNode* BuySListNode(SLTDataType x);申请结点的代码，比较简单，没有什么值得注意的，我们直接看代码：
//单链表结点的动态申请 返回newnode
SListNode* BuySListNode(SLTDataType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);//直接结束
}
else
{
//初始化结点
newnode->Data = x;
newnode->next = NULL;
return newnode;
}
}⟶ 4. 单链表的尾插
//单链表的尾插
void SListPushBack(SListNode** pphead, SLTDataType x);注意：
1. 这个我们为什么要用二级指针呢？
因为我们要改变这个头结点的位置，到时候我们是转递一个指针过来的，而改变指针的方式就是用，指针的指针才能改变。
比如： int a=10;
int b=20;
int* p1=&a;
int* p2=&b;
Swap(&p1,&p2);
void Swap(int** p1,int** p2)
{
int* tmp=*p1;
*p1=*p2;//解引用
*p2=tmp;
}
这样的代码才能改变指针所指向的内容。
2. 需要加一个断言（assert）：
因为plist的地址不可能为空，即使plist指向的内容为空，地址也不可能为空。
我们依旧画图写代码：
代码实现：
//单链表的尾插
void SListPushBack(SListNode** pphead, SLTDataType x)
{
assert(pphead);
SListNode* newnode = BuySListNode(x);//申请一个结点
//1.为空
if (*pphead == NULL)
{
*pphead = newnode;
}
//2.不为空
else
{
SListNode* prev = *pphead;
while (prev->next != NULL)
{
prev = prev->next;//往后走
}
prev->next = newnode;
}
}测试尾插结果：（成功尾插4个数据）
⟶ 5. 单链表的头插
//单链表的头插
void SListPushFront(SListNode** pphead, SLTDataType x);头插代码没有什么好注意的，无论是链表为空还是不为空，此代码都不需要特殊判断：
代码实现：
//单链表的头插
void SListPushFront(SListNode** pphead, SLTDataType x)
{
assert(pphead);
//申请结点
SListNode* newnode = BuySListNode(x);
newnode->next = *pphead;
*pphead = newnode;
}测试头插结果：（插入三个数据成功）
⟶ 6. 单链表的销毁
//单链表的销毁
void SListDestory(SListNode** pphead);怎么销毁呢？我们要看图：
代码实现：
//单链表的销毁
void SListDestory(SListNode** pphead)
{
assert(pphead);
SListNode* cur = *pphead;
while (cur != NULL)
{
//建cur后一个结点
SListNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}⟶ 7. 单链表的头删
//单链表的头删
void SListPopFront(SListNode** pphead);注意：（有两种情况）
1. 当链表为空时，不做删除处理，直接返回或者直接暴力判断。
2. 当链表不为空时，我们按图写代码：
代码实现：
//单链表的头删
void SListPopFront(SListNode** pphead)
{
assert(pphead);
//判断链表是否为空
if (*pphead == NULL)
{
return;
}
//或者 assert(*pphead!=NULL)
SListNode* del = *pphead;
*pphead = (*pphead)->next;
free(del);
del = NULL;
}测试头删：（成功头删）
⟶ 8. 单链表的尾删
//单链表的尾删
void SListPopBack(SListNode** pphead);尾删我们分为三种情况：
1. 没有结点，我们不做出来，直接返回，或者暴力检查。
2. 只有一个结点，释放结点，再置为空。
3. 有多个结点，我们这里看图：
代码实现：
//单链表的尾删
void SListPopBack(SListNode** pphead)
{
assert(pphead);
if (*pphead == NULL)
{
return;
}
//只有一个结点
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
//多个结点
SListNode* tail = *pphead;
while (tail->next->next != NULL)
{
//往后走
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}测试尾删结果：（成功尾删）
⟶ 9. 单链表的查找
//单链表的查找
SListNode* SListFind(SListNode* phead, SLTDataType x)单链表的查找比较简单，我们直接看代码即可：
//单链表的查找
SListNode* SListFind(SListNode* phead, SLTDataType x)
{
SListNode* cur = phead;
while (cur != NULL)
{
//往后遍历
if (cur->Data == x)
{
return cur;
}
cur = cur->next;
}
//找不到
return NULL;
}测试查找结果：（我们这里找单链表中的，数字6）
⟶ 10. 单链表在pos之前插入
//单链表在pos之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x);1. 如果pos在第一个结点，相当于头插。
2. 如果pos在其他位置，我们依旧看图：
代码实现：
//单链表在pos之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);//断言pos不能为空
if (pos == *pphead)
{
//调用头插
SListPushFront(pphead, x);
}
else
{
SListNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
//判断pos是否传错 如果传错 prev==NULL
assert(prev);
}
SListNode* newnode = BuySListNode(x);
prev->next = newnode;
newnode->next = pos;
}
}测试在pos之前插入结果：（在1的前面插入10，成功）
⟶ 11. 单链表在pos之后插入
//单链表在pos之后插入
void SListInsertAfert(SListNode* pos, SLTDataType x);在pos之后插入，我们要注意一点：
先时newnode->next=pos->next;
再使pos->next=newnode;
如果顺序不是相反的话，会照成newnode自己指向自己。
代码实现：
//单链表在pos之后插入
void SListInsertAfert(SListNode* pos, SLTDataType x)
{
assert(pos);
//申请结点
SListNode* newnode = BuySListNode(x);
newnode->next = pos->next;
pos->next = newnode;
}测试在pos之后插入：（插入50成功）
⟶ 12. 删除pos的位置
//单链表删除pos的位置
void SListErase(SListNode** pphead, SListNode* pos);注意：
1. 如果pos的位置是第一个结点，那就调用头删。
2. 其他位置，我们画图见真晓：
代码实现：
//单链表删除pos的位置
void SListErase(SListNode** pphead, SListNode* pos)
{
assert(pphead);
assert(pos);
if (pos == *pphead)
{
//调用头删
SListPopFront(pphead);
}
else
{
//其他位置
SListNode* prev = *pphead;
while (prev->next != pos)
{
//往后走
prev = prev->next;
//判断pos是否在链表中
assert(prev);
}
prev->next = pos->next;
free(pos);
//pos = NULL;//这里置为空，没有用，形参是实参的拷贝
}
}测试删除pos位置的数据：
⟶ 13. 删除pos之后的位置
//单链表删除pos之后的位置
void SListEraseAfter(SListNode* pos);1. 当pos之后的位置为空时，不做处理，直接返回。
2. 当pos在其他位置时，看图得真相：
代码实现：
//单链表删除pos之后的位置
void SListEraseAfter(SListNode* pos)
{
assert(pos);
if (pos->next == NULL)//只有一个结点
{
return;
}
else
{
SListNode* next = pos->next;
pos->next = next->next;
free(next);
}
}测试删除pos之后的结果：（成功删除pos=1之后的位置）
➜ 单链表实现所有源代码
⟶ SList.h 头文件
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
#include
#include
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType Data;
struct SListNode* next;
}SListNode;
//单链表的打印
void SListPrint(SListNode* phead);
//单链表结点的动态申请 返回newnode
SListNode* BuySListNode(SLTDataType x);
//单链表的尾插
void SListPushBack(SListNode** pphead, SLTDataType x);
//单链表的头插
void SListPushFront(SListNode** pphead, SLTDataType x);
//单链表的销毁
void SListDestory(SListNode** pphead);
//单链表的头删
void SListPopFront(SListNode** pphead);
//单链表的尾删
void SListPopBack(SListNode** pphead);
//单链表的查找
SListNode* SListFind(SListNode* phead, SLTDataType x);
//单链表在pos之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x);
//单链表在pos之后插入
void SListInsertAfter(SListNode* pos, SLTDataType x);
//单链表删除pos的位置
void SListErase(SListNode** pphead, SListNode* pos);
//单链表删除pos之后的位置
void SListEraseAfter(SListNode* pos); ⟶ SList.c 源文件
#include"SList.h"
//单链表的打印
void SListPrint(SListNode* phead)
{
SListNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->Data);
cur = cur->next;//cur往后走
}
printf("NULL\n");
}
//单链表结点的动态申请 返回newnode
SListNode* BuySListNode(SLTDataType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);//直接结束
}
else
{
//初始化结点
newnode->Data = x;
newnode->next = NULL;
return newnode;
}
}
//单链表的尾插
void SListPushBack(SListNode** pphead, SLTDataType x)
{
assert(pphead);
SListNode* newnode = BuySListNode(x);//申请一个结点
//1.为空
if (*pphead == NULL)
{
*pphead = newnode;
}
//2.不为空
else
{
SListNode* prev = *pphead;
while (prev->next != NULL)
{
prev = prev->next;//往后走
}
prev->next = newnode;
}
}
//单链表的头插
void SListPushFront(SListNode** pphead, SLTDataType x)
{
assert(pphead);
//申请结点
SListNode* newnode = BuySListNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
//单链表的销毁
void SListDestory(SListNode** pphead)
{
assert(pphead);
SListNode* cur = *pphead;
while (cur != NULL)
{
//建cur后一个结点
SListNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}
//单链表的头删
void SListPopFront(SListNode** pphead)
{
assert(pphead);
//判断链表是否为空
if (*pphead == NULL)
{
return;
}
//或者 assert(*pphead!=NULL)
SListNode* del = *pphead;
*pphead = (*pphead)->next;
free(del);
del = NULL;
}
//单链表的尾删
void SListPopBack(SListNode** pphead)
{
assert(pphead);
if (*pphead == NULL)
{
return;
}
//只有一个结点
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
//多个结点
SListNode* tail = *pphead;
while (tail->next->next != NULL)
{
//往后走
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
//单链表的查找
SListNode* SListFind(SListNode* phead, SLTDataType x)
{
SListNode* cur = phead;
while (cur != NULL)
{
//往后遍历
if (cur->Data == x)
{
return cur;
}
cur = cur->next;
}
//找不到
return NULL;
}
//单链表在pos之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);//断言pos不能为空
if (pos == *pphead)
{
//调用头插
SListPushFront(pphead, x);
}
else
{
SListNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
//判断pos是否传错 如果传错 prev==NULL
assert(prev);
}
SListNode* newnode = BuySListNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
//单链表在pos之后插入
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
assert(pos);
//申请结点
SListNode* newnode = BuySListNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
//单链表删除pos的位置
void SListErase(SListNode** pphead, SListNode* pos)
{
assert(pphead);
assert(pos);
if (pos == *pphead)
{
//调用头删
SListPopFront(pphead);
}
else
{
//其他位置
SListNode* prev = *pphead;
while (prev->next != pos)
{
//往后走
prev = prev->next;
//判断pos是否在链表中
assert(prev);
}
prev->next = pos->next;
free(pos);
//pos = NULL;//这里置为空，没有用，形参是实参的拷贝
}
}
//单链表删除pos之后的位置
void SListEraseAfter(SListNode* pos)
{
assert(pos);
if (pos->next == NULL)//只有一个结点
{
return;
}
else
{
SListNode* next = pos->next;
pos->next = next->next;
free(next);
}
}⟶ Test.c 源文件
#include"SList.h"
void test1()
{
SListNode* plist = NULL;
//测试尾插
SListPushBack(&plist, 1);
SListPushBack(&plist, 2);
SListPushBack(&plist, 3);
SListPushBack(&plist, 4);
//测试头插
SListPushFront(&plist, 5);
SListPushFront(&plist, 6);
SListPushFront(&plist, 7);
SListPrint(plist);
//测试头删
SListPopFront(&plist);
SListPrint(plist);
//测试尾删
SListPopBack(&plist);
SListPrint(plist);
//测试查找
SListNode* pos = SListFind(plist, 1);
if (pos)
{
/*printf("找到了\n");*/
//测试在pos之前插入数据
SListInsert(&plist, pos, 10);
//测试在pos之后插入数据
SListInsertAfter(pos, 50);
SListPrint(plist);
//测试删除pos位置
/*SListErase(&plist, pos);
SListPrint(plist);*/
//删除pos之后的位置
SListEraseAfter(pos);
SListPrint(plist);
}
SListDestory(&plist);
}
int main()
{
test1();
return 0;
}➜ 结束语
各位大佬好，今天这个无头非循环单向链表就实现到这里了，希望这篇接近万字的实现单链表的博客能够，使各位大佬温习或者更加深刻的去理解单链表的实现过程。都看到这了，给个三联吧！！！
