在上一节我们学习了线性表中的顺序表，今天我们来学习一下线性表中的另一种结构——单链表
前言
我们在之前已经初步了解了数据结构中的两种逻辑结构，但线性结构中并非只有顺序表一种，它还有不少兄弟姐妹，今天我们再来学习一下单链表。
一、单链表是什么？
单链表是一种基础的数据结构，用于存储一系列元素。它由一系列节点（node）组成，每个节点包含两个部分：一个数据部分和一个指向下一个节点的指针部分。它与我们上一节学习的顺序表有所不同，仅能根据数组的下标来确定位置，单链表它能够根据它结点中的指针来找寻下一个结点，这样无形之中就能提高存取数据的灵活性了。
与顺序表不同的是，链表中的元素的存储空间都是独立申请下来的，我们称之为“结点”，结点一般都是从堆上申请下来的（一般通过malloc,realloc等动态内存分配函数来进行申请空间的），这些从堆上申请的空间，是按照一定的策略分配出来的，每次申请的空间可能连续，也可能不连续。这就是它在物理结构上不连续的一个原因了。
结点中包含两个域：其中存储元素信息的域称为数据域；存储直接后继存储位置的域称为指针域。
对于这个结点，还有不少学问呢！接下来我们来对首元结点，头结点，头指针3个容易混淆的概念进行说明。
（1）首元结点是用来存储链表中第一个数据元素的结点。
（2）头结点是在首元结点之前的一个结点，它的指针域指向首元结点的位置，头结点的数据域中可以不存放任何信息，也可以存储与数据元素类型相同的其他附加信息。例如当数据元素为整型时，头结点的数据域可以存放该链表的长度（因为长度一般是整型类型）。
（3）头指针是指向链表中第一个结点的指针，若链表中设有头结点，那么头指针就指向头结点，若没有设头结点，头指针就直接指向首元结点。
这时候，就会有人要问了：既然已经有了首元结点了，为啥还要设置一个头结点呢？这不是画蛇添足嘛。现在，我来给你们介绍一下有头结点的好处：
1）便于对首元结点的处理：有了头结点之后，我们能够更好地处理有关首元结点的操作，比如插入删除等操作，我们也不必为它特意写个函数来实现这些功能了，我们使用正常的插入删除操作就能够实现它了。
2）便于对空表与非空表的统一处理：当链表不设置头结点时，假设L为该链表的头指针，它应该指向首元结点，当单链表的长度为0时的空表时，L指针为空（判定链表为空表的条件就是：L==NULL）我们要知道，我们一般都是将结点的指针域指向NULL的，现在咱们将头指针指向NULL，那么我们就会造成一个误解：这个头指针是个NULL。当我们增加头结点之后，无论链表是否为空，头指针都是指向首元结点的非空指针。（判定链表为空表的条件就是：L->next==NULL)下图是设有头结点的单链表
二、单链表与顺序表的比较
首先我们先对它们的概念进行一下对比：
单链表：单链表是逻辑结构上连续，物理结构上不连续的数据结构，数据元素中的逻辑顺序是通过链表中的指针链接次序实现的。
顺序表：顺序表是逻辑结构上连续，物理结构上也连续的数据结构，数据元素的逻辑顺序是通过数组下标进行实现的。
空间性能的比较
(1)存储空间的分配：顺序表的存储空间是必须预先分配的，元素个数具有一定限制，容易造成空间浪费或者空间溢出的情况；而链表可以根据数据元素来进行分配空间，只要内存空间允许，链表中的元素个数就没有限制，可以说有几个元素给几个结点空间。
（2）存储密度的大小：由于链表中除了设置了数据域还设置了指针域，用来存储元素之间逻辑关系的指针。从存储密度上来说，这是不经济的。所谓存储密度就是存放数据的空间占据结点空间的比例
当存储密度越高，那么存储空间的利用率就越高。由此我们可以知道，顺序表的存储利用率是100%，因为它整个结点都存放着数据，而链表中由于存放了指针域，那么它的存储利用率就小于100%。
由上面的两个比较，我们可以得出一个结论：当线性表的长度较大且难以估测存储规模时，宜采用链表作为存储结构；当线性表的长度不大且我们事先已经知道其具体大小时，为了节约存储空间，宜采用顺序表来作为存储结构。
时间性能的比较
（1）存取元素的效率：由于上面两种的物理结构有所不同，它们的存取方式也有所不同。其中，顺序表是随机存取（因为它的底层基础是数组，数组具有下标，当我们想要查找某个元素时，可以直接根据数组下标来查找相应的元素），链表是顺序存取（因为链表是由一个个结点通过结点中的指针域链接而成的，因此我们每次在查找某个元素时，只能够通过指针从首元结点开始逐个遍历来找到相应的元素）这里它们两个的时间复杂度也不同，前者是O(1)，后者是O（N）。
（2）插入与删除操作的效率：对于链表已经确定的元素插入删除的位置后，插入删除操作无须移动数据，只要修改指针即可，时间复杂度为O（1）。而对于顺序表，即使已经知道要插入删除的位置之后，我们在进行插入删除操作时，仍要进行大量元素的移动来实现，时间复杂度为O（N）。而且当每个结点的信息量较大时，移动结点的时间开销就很多了。因此对于频繁进行插入删除操作的线性表，宜采用链表作为存储结构。
三、单链表的实现
接下来我们来介绍一下如何来实现一个单链表，接下来我将我写的源代码与一些注释附上。与顺序表一样，我们也将单链表分为三个文件：SList.h ,SList.c, test.c。
SList.h
#pragma once
typedef int SLTDatatype; //定义一个数据变量，方便后面一键替换数据类型
//定义一个单链表结点
typedef struct SListNode
{
SLTDatatype data;//存放数据
struct SListNode* next;//指向下一个结点的地址
}SLTNode;
//链表的打印
void SLTPrint(SLTNode* phead);
//插入
//插入新结点（每次插入前要申请一个新的结点）
//由于头插，尾插都有可能涉及到头指针，因此形参我们要使用二级指针，实参要传递的是一级指针的地址
void SLTPushBack(SLTDatatype**pphead,SLTDatatype x);
void SLTPushFront(SLTDatatype**pphead, SLTDatatype x);
//删除
void SLTPopBack(SLTNode**pphead);
void SLTPopFront(SLTNode**pphead);
//查找
SLTNode* SLFind(SLTNode* phead,SLTDatatype x);
//在指定位置之前插入数据
void SLTInsert(SLTDatatype** pphead, SLTNode* pos, SLTDatatype x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTDatatype** pphead, SLTNode* pos, SLTDatatype x);
//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SLDestroy(SLTNode**pphead);由上面的代码，我们可以看出，我们在定义一个结点的时候，在结构体中只有两个成员元素：数据域，指针域。另外，这里函数里面传递的参数我们也要注意一下：与之前的顺序表不同，之前的顺序表我们是由数组来实现的，因此我们传递参数时，直接就传递了链表的指针变量即可，但是现在我们在链表中，我们本身就是通过指针来找寻下一个结点的位置，因此我们在传递参数的时候我们要传递的是链表指针的地址，我们在之前学过：存放一级指针的地址的指针叫做二级指针。于是我们的参数传递的就是一个二级指针。（注意：我们传递二级指针作为参数的一定是在那个函数中，我们需要对那个头指针进行相关解引用操作）
SList.c
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//申请一个新结点
SLTNode* SLTBuyNode(SLTDatatype x)
{
SLTNode* node = (SLTNode*)malloc(sizeof(SLTDatatype));
if (node == NULL)
{
perror("malloc");
exit(1);
}
//将结点中的数据内容初始化
node->data = x;
node->next = NULL;
return node;
}
//打印链表
void SLTPrint(SLTNode* phead)
{
//定义一个指针，后面来遍历链表。初始位置指向phead头指针
SLTNode* pcur = phead;
while (pcur) //pcur!=NULL
{
printf("%d->", pcur->data);
pcur = pcur->next; //使指针pcur不断向后移动
}
printf("NULL\n");//链表的最后一个结点的指针域指向NULL的
}
//尾插
void SLTPushBack(SLTDatatype** pphead, SLTDatatype x)
{
assert(pphead);//防止头指针的地址找不到
//pphead这是二级指针，即pphead==&phead
//*pphead==phead(这就是头指针的指针，存放着头指针的地址)，**pphead==*phead即头指针地址指向的那个结点
SLTNode* newnode = SLTBuyNode(x);//定义一个新结点，等会进行插
if (*pphead == NULL)
{
//这种情况是空链表，因此头指针指向NULL，然后直接加入新节点
*pphead = newnode;
}
else
{
//这种情况是不是空链表，因此我们要找插入的位置
//首先找一个尾结点，然后在尾结点后面进行插入新结点，即尾插
SLTNode* pcur = *pphead; //这里定义一个新的指针是为了后面方便找尾结点的，必须将其初始化为头指针，否则它不是从头指针开始遍历查找
while (pcur->next ) //这里的条件是为了找尾结点，只要这个结点的下一个结点是一个NULL。那么就可以确认了这是一个尾结点
{
pcur = pcur->next;
}//pcur nownode
pcur->next = newnode;//将新节点的地址传递给尾结点的指针域，那么newnoda就变成尾结点了
}
}
//头插
void SLTPushFront(SLTDatatype** pphead, SLTDatatype x)
{
assert(pphead);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = *pphead;// 我们将新插入的新节点的指针域指向头指针，注意：我们要赋值的是头指针（已经是一个地址了，如果我们直接写pphead，这是头指针的地址）
*pphead = newnode; //然后将新节点的地址赋给头指针，即新节点作为头指针
}
//头删
void SLTPopFront(SLTNode**pphead)
{
assert(pphead && *pphead);//判断不是一个空链表且头指针的地址要存在
SLTNode* next = (*pphead)->next; //在删除之前，咱们可以先用一个next结点将头指针下一个结点的地址保存下来
free(*pphead); //将头指针删除
*pphead = next; //再将下一个结点作为头指针
}
//尾删
void SLTPopBack(SLTNode** pphead)
{
assert(pphead && *pphead);
//尾删分两种情况：一种：只有一个结点，直接删除释放；一种：有好几个结点，我们要先找到最后一个结点，然后再进行删除
if ((*pphead)->next == NULL)//如果下一个结点是一个NULL，那么这只有一个结点
{
free(*pphead);
*pphead = NULL;
}
else
{
//这种情况我们要找到最后一个结点并且将它删掉，因此我们还要找到最后一个结点的前一个结点
SLTNode* ptail = *pphead; //最后一个结点
SLTNode* prev = NULL; //最后一个结点的前一个结点
while (ptail->next )
{
prev = ptail; //最后一个结点的位置给它上一个结点
ptail = ptail->next; //结点不断向后移动
}
prev->next = NULL; //将上一个结点的指向的内容设为NULL，因为此时已经是尾结点了
free(ptail);
ptail = NULL;
}
}
//查找
SLTNode* SLFind(SLTNode* phead,SLTDatatype x)
{
assert(phead); //判断链表要不为空
SLTNode* pcur = phead;
while (pcur)
{
if (pcur->data == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
//在指定位置之前插入数据
void SLTInsert(SLTDatatype** pphead, SLTNode* pos, SLTDatatype x)
{
assert(pphead && pos);
if (pos == *pphead)
{
SLTPopFront(**pphead);
}
else
{
//先创建一个新节点
SLTNode* newnode = SLTBuyNode(x);
SLTNode* prev = *pphead;
while (prev->next=pos )
{
prev = prev->next;
}
newnode->next = pos;
prev->next = newnode;
}
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTDatatype** pphead, SLTNode* pos, SLTDatatype x)
{
assert(pphead && pos);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
//删除pos结点
void SLTErase(SLTNode**pphead, SLTNode* pos)
{
assert(pphead && pos &&*pphead );
if (pos==*pphead)
{
SLTPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
//prev pos pos->next
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos)
{
assert(pos && pos->next );
SLTNode* del = pos->next;
pos->next = pos->next->next;
free(del);
del = NULL;
}
//销毁链表
void SLDestroy(SLTNode**pphead)
{
assert(*pphead && pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
}在这个文件中，我们所要实现的就是单链表。在这里面有些我重点拿出来讲讲（其实在上面的源代码中的注释已经很详细了）
（1）我们要有一个创建一个新结点的操作，因为在后续操作中，插入首先都是创建一个新结点，然后再进行插入；
（2）我们如果想要查找某个元素或者在某个位置插入删除，在此之前，我们要新定义一个新的指针来遍历链表，找到自己想要的位置，我们在定义的时候一般都是将该指针指向头指针的位置；
（3）我们在进行删除操作的时候，有时候我们如果想要释放某个结点空间的时候，我们在移动链表之前，一定要定义一个新的指针来存放那个将要删除的结点地址，因为我们要知道一旦我们移动链表，如果将那个结点覆盖掉了就没了，我们因此就无法释放那个空间了;
test.c
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"
#include<stdio.h>
#include<stdlib.h>
void SLTtest()
{
SLTNode* plist = NULL;//定义初始化一个头指针
//尾插
SLTPushBack(&plist, 1);
SLTPushBack(&plist, 2);
SLTPushBack(&plist, 3);
SLTPushBack(&plist, 4);
SLTNode*find= SLFind(plist, 33);
if (find == NULL)
{
printf("没找到\n");
}
else
{
printf("找到了\n");
}
SLDestroy(&plist);
SLTPrint(plist);
//头插
SLTPushFront(&plist, 9);
SLTPushFront(&plist, 8);
SLTPushFront(&plist, 7);
SLTPushFront(&plist, 6);
SLTPrint(plist);
SLTPopBack(&plist);
SLTPrint(plist);
SLTPopBack(&plist);
SLTPrint(plist);
SLTPopBack(&plist);
SLTPrint(plist);
SLTPopBack(&plist);
SLTPrint(plist);
}
int main()
{
SLTtest();
return 0;
}上面这个文件，我们是用来进行测试，我们在写好某个功能之后，可以到这个test.c进行测试一下，咱们一部分一部分地测试，最后咱们就能写好一个单链表了。
总结
我们这节学习的单链表与上一节学习的顺序表有着不少相似之处，但是二者的区别也是很大的，希望大家能够熟练掌握这两种数据结构的实现。最后告诉大家：孰能生巧！
扫一扫
128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
