Hi~！这里是奋斗的小羊，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
💥💥个人主页：奋斗的小羊
💥💥所属专栏：数据结构
🚀本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为记录我的学习过程及理解。文笔、排版拙劣，望见谅。
目录
前言
顺序表插入、删除数据后将有大量的数据需要挪动位置，顺序表增容也存在空间浪费，与顺序表相比，链表没有这些问题，链表在处理数据上更为灵活、经济。
链表也是线性表的一种，也就是说链表在逻辑结构上一定是连续的，而与顺序表不同的是链表在物理结构上不一定连续。既然在物理结构上不一定连续，那链表是如何做到管理数据的呢？这就是接下来我们将要探讨的问题。
本篇文章介绍单链表。
1、单链表的实现逻辑
我们知道了链表在物理结构上不一定连续，但是它却能做到管理数据，这是因为我们将下一个数据的地址和第一个数据存到一起，第一个数据的地址我们是很容易得到的，当我们找到第一个数据时就能通过下一个数据的地址来找到下一个数据，依次类推，我们就能将大量的数据串起来，以达到管理的目的。
这是单链表的实现逻辑，其他链表也是类似的方法。
2、单链表的实现
2.1节点的创建和申请
要将数据和地址存到一起，很明显需要用到结构体，这个结构体类型我们就把它当做一个节点。
每个节点只能存一个数据，那么每个节点的地址就需要一个结构体类型指针来接收。
为了存储不同类型的数据，我们使用typedef来重定义类型名。
//数据类型
typedef int slist_data_type;
//单链表
typedef struct slist
{
slist_data_type data;
struct list* next;
}slist;
这样我们就创建好了节点。
在插入数据前先要申请空间，因为每插入一个数据申请一个空间，并且每个空间一般没有联系，所以我们优先使用malloc函数。
申请好空间后我们顺手将需要插入的数据存进去，再将这个空间的地址返回，由上一个节点内的指针接收。
//申请节点
slist* slist_buy(slist_data_type x)
{
slist* newslist = (slist*)malloc(sizeof(slist));//slist s = { 0 };
if (newslist == NULL)
{
perror("malloc fail!");
return 1;
}
else
{
newslist->data = x;
newslist->next = NULL;
return newslist;
}
}
需要注意的是本次申请的节点内指向下一个节点的指针需要置NULL。
2.2数据的打印和查找
我们经常需要将单链表中存的数据打印出来，或者在单链表中查找一个数据是否存在，为了方便，这两个步骤也封装成函数。
打印单链表的数据需要借助头指针来依次找到其他节点，结束打印的条件就是最后一个节点内指针为NULL。
//打印
void slist_print(const slist* phead)
{
slist* pcur = phead;
while (pcur != NULL)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("NULL\n");
}
在单链表中找一个数据和打印数据是类似的，值得注意的是找到查找的数据后我们需要将这个数据所在节点的地址返回，如果没找到则返回NULL。
//查找
slist* slist_find(slist* phead, slist_data_type x)
{
slist* pcur = phead;
while (pcur != NULL)
{
if (pcur->data == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
2.3头插和尾插
申请好一个空间后，我们要在这个空间内存入第一个数据当做头节点，头节点的地址需要存起来，以后访问数据就通过这个头节点的地址来访问。
定义一个结构体指针初始置为NULL，这个指针是用来接收第一个节点的地址的，因此我们在函数传参的时候要传址。
slist* plist = NULL;
slist_push_front(&plist, 1);
头插的函数如下：
//头插
void slist_push_front(slist** pphead, slist_data_type x)
{
assert(pphead != NULL);
slist* newslist = slist_buy(x);
newslist->next = *pphead;
*pphead = newslist;
}
头插的过程其头节点的地址是不断更新的。
尾插相对来说较为麻烦一点，因为尾插之前我们需要判断一下当前单链表是否有节点，如果没有节点，则新申请的这个节点就要作为头节点。
如果尾插之前这个单链表有若干个节点，则我们需要找到最末端的节点，将申请到的这个节点接到末端。
//尾插
void slist_push_back(slist** pphead, slist_data_type x)
{
assert(pphead != NULL);
if (*pphead == NULL)
{
*pphead = slist_buy(x);
}
else
{
//找尾节点
slist* ptail = *pphead;//ptail中存的是头节点的地址
while (ptail->next != NULL)
{
ptail = ptail->next;
}
ptail->next = slist_buy(x);
}
}
2.4在指定位置之前 \ 之后插入
我们现在知道某个节点的地址，需要在这个地址对应的节点之前插入一个节点，但开头我们就说过，单凭一个节点的地址是没办法找到这个节点之前的节点的，因此我们需要通过头节点的地址来找到这个位置的前一个节点。
将申请到的节点插入到上一个节点的尾部，指定位置节点的头部插入到申请到的节点的尾部，手拉手重新串起来。
- 这个函数的前提是单链表至少有一个节点，如果没有节点则未定义。
- 如果指定位置为头节点，即为头插，要特殊处理。
//在指定位置之前插入数据
void slist_insert_front(slist** pphead, slist* pos, slist_data_type x)
{
assert(pphead && *pphead && pos);
//头插
if (*pphead == pos)
{
slist_push_front(pphead, x);
}
else
{
slist* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
slist *newslist = slist_buy(x);
pcur->next = newslist;
newslist->next = pos;
}
}
在指定位置之后插入只需要将申请到的节点地址插入到指定位置节点内的指针中，再将下一个节点的地址插入到新节点内的指针中。
//在指定位置之后插入数据
void slist_insert_back(slist* pos, slist_data_type x)
{
assert(pos);
slist* newslist = slist_buy(x);
newslist->next = pos->next;
pos->next = newslist;
}
2.5头删和尾删
和头插一样，头删也会改变头指针的指向，因此在删除头节点前应该将下一个节点的地址先保存。
//头删
void slist_pop_front(slist** pphead)
{
assert(pphead && *pphead);
slist* pcur = *pphead;
*pphead = pcur->next;
free(pcur);
pcur = NULL;
}
尾删则相对麻烦一点，如果当前单链表只有一个节点，则直接将这个节点释放掉就可。
如果当前单链表有多个节点，则需要在尾删后将新的尾节点内指针置NULL。
//尾删
void slist_pop_back(slist** pphead)
{
assert(pphead && *pphead);
//只有一个节点
//直接将这个节点释放就可
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
//有多个节点
else
{
slist* prev = *pphead;
slist* ptail = *pphead;
while (ptail->next != NULL)
{
prev = ptail;
ptail = ptail->next;
}
prev->next = NULL;
free(ptail);
ptail = NULL;
}
}
2.6删除指定位置的节点
删除指定位置的节点，最重要的是在删除节点后能将前后节点给接起来，后节点的地址存到前节点内，这就要求我们在删除指定位置的节点前先找到指定位置之前的一个节点，而仅通过指定的位置是无法找到前一个节点的，因此我们还要借助头节点的地址。
最后，在释放掉指定位置的节点后，还要给指向指定位置的指针置NULL，这是为了防止野指针的出现。
//删除指定位置的节点
void slist_erase(slist** pphead, slist* pos)
{
assert(pphead && *pphead && pos);
if (*pphead == pos)
{
//头删
slist_pop_front(pphead);
}
else
{
slist* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
pcur->next = pos->next;
free(pos);
pos = NULL;
}
}
2.7单链表的销毁
因为每个节点都是我们用动态内存开辟函数malloc申请的空间，所以在程序最后需要我们手动释放掉这些空间，避免内存泄漏。
需要利用头节点的地址依次释放，在释放当前的节点之前，需要通过当前节点的地址找到下一个节点的地址存起来再释放，如果直接释放掉当前的节点将无法找到下一个节点。
//销毁链表
void slist_destroy(slist** pphead)
{
assert(pphead && *pphead);
slist* pcur = *pphead;
while (pcur != NULL)
{
slist* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
}
3、单链表完整代码
slist.h:
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//数据类型
typedef int slist_data_type;
//单链表
typedef struct slist
{
slist_data_type data;
struct list* next;
}slist;
//打印数据
void slist_print(const slist* phead);
//尾插
void slist_push_back(slist** pphead, slist_data_type x);
//头插
void slist_push_front(slist** pphead, slist_data_type x);
//尾删
void slist_pop_back(slist** pphead);
//头删
void slist_pop_front(slist** pphead);
//查找
slist* slist_find(slist* phead, slist_data_type x);
//在指定位置之前插入数据
void slist_insert_front(slist** pphead, slist* pos, slist_data_type x);
//在指定位置之后插入数据
void slist_insert_back(slist* pos, slist_data_type x);
//删除指定位置的节点
void slist_erase(slist** pphead, slist* pos);
//删除指定位置之后的节点
void slist_erase_back(slist* pos);
//销毁链表
void slist_destroy(slist** pphead);
slist.c:
#define _CRT_SECURE_NO_WARNINGS
#include "slist.h"
//打印
void slist_print(const slist* phead)
{
slist* pcur = phead;
while (pcur != NULL)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("NULL\n");
}
//申请节点
slist* slist_buy(slist_data_type x)
{
slist* newslist = (slist*)malloc(sizeof(slist));//slist s = { 0 };
if (newslist == NULL)
{
perror("malloc fail!");
return 1;
}
else
{
newslist->data = x;
newslist->next = NULL;
return newslist;
}
}
//尾插
void slist_push_back(slist** pphead, slist_data_type x)
{
assert(pphead != NULL);
if (*pphead == NULL)
{
*pphead = slist_buy(x);
}
else
{
//找尾节点
slist* ptail = *pphead;//ptail中存的是头节点的地址
while (ptail->next != NULL)
{
ptail = ptail->next;
}
ptail->next = slist_buy(x);
}
}
//头插
void slist_push_front(slist** pphead, slist_data_type x)
{
assert(pphead != NULL);
slist* newslist = slist_buy(x);
newslist->next = *pphead;
*pphead = newslist;
}
//尾删
void slist_pop_back(slist** pphead)
{
assert(pphead && *pphead);
//只有一个节点
//直接将这个节点释放就可
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
//有多个节点
else
{
slist* prev = *pphead;
slist* ptail = *pphead;
while (ptail->next != NULL)
{
prev = ptail;
ptail = ptail->next;
}
prev->next = NULL;
free(ptail);
ptail = NULL;
}
}
//头删
void slist_pop_front(slist** pphead)
{
assert(pphead && *pphead);
slist* pcur = *pphead;
*pphead = pcur->next;
free(pcur);
pcur = NULL;
}
//查找
slist* slist_find(slist* phead, slist_data_type x)
{
slist* pcur = phead;
while (pcur != NULL)
{
if (pcur->data == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
//在指定位置之前插入数据
void slist_insert_front(slist** pphead, slist* pos, slist_data_type x)
{
assert(pphead && *pphead && pos);
//头插
if (*pphead == pos)
{
slist_push_front(pphead, x);
}
else
{
slist* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
slist *newslist = slist_buy(x);
pcur->next = newslist;
newslist->next = pos;
}
}
//在指定位置之后插入数据
void slist_insert_back(slist* pos, slist_data_type x)
{
assert(pos);
slist* newslist = slist_buy(x);
newslist->next = pos->next;
pos->next = newslist;
}
//删除指定位置的节点
void slist_erase(slist** pphead, slist* pos)
{
assert(pphead && *pphead && pos);
if (*pphead == pos)
{
//头删
slist_pop_front(pphead);
}
else
{
slist* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
pcur->next = pos->next;
free(pos);
pos = NULL;
}
}
//删除指定位置之后的节点
void slist_erase_back(slist* pos)
{
assert(pos && pos->next);
slist* next = pos->next;
pos->next = next->next;
free(next);
next = NULL;
}
//销毁链表
void slist_destroy(slist** pphead)
{
assert(pphead && *pphead);
slist* pcur = *pphead;
while (pcur != NULL)
{
slist* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
}
test.c:
#define _CRT_SECURE_NO_WARNINGS
#include "slist.h"
void test1()
{
slist* plist = NULL;
slist_push_back(&plist, 1);
slist_push_back(&plist, 2);
slist_push_back(&plist, 3);
slist_push_back(&plist, 4);
slist_print(plist);
//slist_push_front(&plist, 5);
//slist_push_front(&plist, 6);
//slist_push_front(&plist, 7);
//slist_print(plist);
//slist_pop_back(&plist);
//slist_print(plist);
//slist_pop_back(&plist);
//slist_print(plist);
//slist_pop_front(&plist);
//slist_print(plist);
//slist *ret = slist_find(plist, 0);
//if (ret == NULL)
//{
// printf("没有找到！\n");
//}
//else
//{
// printf("找到了！\n");
//}
//slist* find = slist_find(plist, 3);
//slist_insert_front(&plist, find, 5);
//slist_insert_back(find, 6);
//slist_print(plist);
//slist* find = slist_find(plist, 3);
//slist_erase(&plist, find);
//slist_print(plist);
slist_destroy(&plist);
}
int main()
{
test1();
return 0;
}
总结
单链表和顺序表是两种常见的数据结构，在不同的场景下有各自的优势和劣势：
- 单链表在插入和删除节点时只需修改指针，时间复杂度为O(1)，而顺序表插入和删除操作需要移动元素，时间复杂度为O(n)
- 单链表需要从头节点开始沿着指针一个一个遍历到目标节点，时间复杂度为O(n)，而顺序表可以通过下标直接访问元素，时间复杂度为O(1)
- 单链表只在需要时分配内存，不存在容量限制，灵活性更高
- 单链表每个节点都需要额外一个指针，增加了存储空间开销
总的来说，如果需要频繁进行插入和删除操作，并且不关心随机访问效率，那么单链表是一个更好的选择；如果需要频繁进行随机访问操作，顺序表可能更适合。
2882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
