数据结构（三）单链表

前言：在介绍顺序表时，咱们提到了线性表。而今天学习的链表也是线性表。

回顾一下线性表的概念：

逻辑结构：一定是线性的。
物理结构：不一定是线性的。

今天学习的链表他就是逻辑结构是线性，而物理结构不是线性的。

1. 链表的概念及结构

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

链表的结构跟⽕⻋⻋厢相似，是由一节一节车厢组成的。想要通过上一个车厢去往下一个车厢，那么就需要通过车厢相连的通道去进入下一个车厢。淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。

在链表⾥，每节“⻋厢”是什么样的呢？

与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/节点”。

节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希
望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下⼀个节点的位置？
链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针
变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

结合前⾯学到的结构体知识，我们可以给出每个节点对应的结构体代码：
为了方便修改各种类型，这里我们typedef 一下类型名。这里使用的是int类型。

typedef int SLTDataType;
//链表是由节点组成的
typedef struct SListNode
{
	SLTDataType data;//节点保存的数据
	struct SListNode* next;//指针保存下一个节点的地址
}SLTNode;

当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个
节点的钥匙）就可以了。

那我们现在手搓一个链表，看一下链表的结构和组成。

void SlistTest01()
{
	//一般不会这样去创建链表，这里只是为了给大家展示链表的打印
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;
	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;
	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;
	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	SLTNode* plist = node1;
	SLTPrint(plist);

}

//打印链表：

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;//将头结点的地址给pcur遍历
	while (pcur)//遍历直到pcur指向NULL结束遍历
	{
		printf("%d->",pcur->data);//打印当前节点的数据
		pcur=pcur->next;//指向下一个节点
	}
	printf("\n");
}

执行结果：

在这里我只是为大家展示一下链表的打印，一般情况下，我们是不会这样创建链表的。

补充说明：
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续
2、节点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续

接下来就带着大家学习一下单链表的具体实现。

2. 单链表的实现

在这里我们要创建：SList.h SList.c test.c 三个文件。

SList.h：定义链表的结构，链表要实现的接口/方法。
SList.c：具体实现链表里定义的接口/方法。
test.c：测试动作：测试链表的各个接口/方法。

2.1 SList.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
//链表是由节点组成的
typedef struct SListNode
{
	SLTDataType data;//节点保存的数据
	struct SListNode* next;//指针保存下一个节点的地址
}SLTNode;

//打印链表
void SLTPrint(SLTNode* phead);//phead指向第一个节点的指针
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//头插

void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);

//头删
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDesTroy(SLTNode** pphead);

2.2 SList.c

这一步让我们逐步详解SList.c：具体实现链表里定义的接口/方法。

2.2.1 链表尾插：

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	//链表为空，新节点作为phead
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail->next = newnode;
}

在链表不为空的时候，我们创建ptail指针，遍历链表找到指向空的节点，创建新的节点，让ptail->next
指向newnode新的节点，然后让新的节点指向NULL。
如果链表为空，我们就将新的节点的next指向NULL就可以了。

因为节点node是由指针*plist接收的，这里如果传plist，接收只用一级指针 *phead接收的话，接收的是第一个节点的地址并不能修改节点的值。所以我们这里要使用二级指针 **pphead接收&plist。

在test.c打印测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
}
int main()
{
	/*SlistTest01();*/
	SlistTest02();
	return 0;
}

执行结果：

2.2.2 链表头插：

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = *pphead;
	*pphead = newnode;
	
}

头插就可以直接一些了，直接让新节点newnode指向phead头结点，然后让头结点指向newnode。

在test.c打印测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
}
int main()
{
	/*SlistTest01();*/
	SlistTest02();
	return 0;
}

执行结果：

2.2.3 创建节点：

在头插和尾插我们发现需要多次创建新的节点，那么我们就可以创建一个函数，需要时直接调用函数，增加效率，减少多次反复使用的代码。

SLTNode* SLTBuyNode(SLTDataType x) {
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

2.2.4 链表尾删

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);//指向第一个节点的地址

	//链表不为空
	//链表只有一个节点，有多个节点
	if (( * pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;
	//销毁尾节点
	free(ptail);
	ptail = NULL;
}

尾删时，链表不得为空。在此还要分俩种情况一种时只有一个节点，另一种还有多个节点。
那么只有一个节点时，咱们就直接销毁就可以了。如果有多个节点，将最后一个节点销毁后，要让最后一个节点的前一个指向NULL。

在test.c打印测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);

}
int main()
{
	/*SlistTest01();*/
	SlistTest02();
	return 0;
}

执行结果：

2.2.5 链表头删

//头删
void SLTPopFront(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead);
	//链表指向的第一个节点的地址
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头结点释放掉
	SLTNode* next = NULL;
	next = (*pphead)->next;
	free(*pphead);
	*pphead = next;

}

头删时，链表不得为空。在这里和顺序表对比一下就方便很多，我们只需要创建一个新的指针变量来保存头结点的下一个节点，然后将头结点*pphead free释放掉，然后将新的头结点赋值给 *pphead就可以了。

测试一下头删：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	
}
int main()
{
	SlistTest02();
	return 0;
}

测试结果：

2.2.6 链表查找

//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur)//等价于pcur ！= NULL
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

在链表查找就很简单了，这里我们定义一个pcur来遍历整个链表，当pcur指向的链表的值等于你要查找的值时那么返回这个节点的地址，如果没有找到就返回一个NULL就可以了。

测试一下

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTNode* FindRet = SLTFind(&plist, 4);
	if (FindRet) {
		printf("找到了！\n");
	}
	else {
		printf("未找到！\n");
	}
	
}
int main()
{
	SlistTest02();
	return 0;
}

执行结果：

2.2.7 在指定位置前插入数据

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//为什么要加上链表不能为空
	assert(*pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//pos刚好是头结点的情况
	if (pos == *pphead) {
		//头插
		SLTPushFront(pphead, x);
		return;
	}
	//pos不是头结点的情况
	
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}

在指定位置前插入数据要判断头结点不得空，链表是不得空。因为这里要传的pos证明这个链表不是一个空链表。在这里我们创建一个新节点，让pos前的节点指向这个新节点，让这个新节点指向pos节点就可以了。

测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTNode* FindRet = SLTFind(&plist, 4);
	
	SLTInsert(&plist, FindRet, 100);
	SLTPrint(plist);
}
int main()
{
	SlistTest02();
	return 0;
}

执行结果：

2.2.8 在指定位置后插入数据

//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

这里就非常简单了，但是我们要注意一个问题，让插入的新节点先指向pos指向的下一个节点，然后让pos指向新的节点，如果顺序不对可能会造成数据的丢失。

测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTNode* FindRet = SLTFind(&plist, 4);
	
	SLTInsertAfter(FindRet,100);
	SLTPrint(plist);
}
int main()
{
	SlistTest02();
	return 0;
}

测试结果：

2.2.9 删除pos节点

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是头结点，没有前驱节点，直接执行头删
	if (*pphead == pos) {
		//头删
		SLTPopFront(pphead);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos= NULL;
}

删除pos节点，我们先判断它是不是头结点，如果是直接头删就可以了，如果不是，我们就需要prev来遍历整个链表，当prev的下一个节点是pos的时候，我们先让prev的下一个节点指向pos指向的下一个节点。然后在释放掉pos，让pos为NULL。

测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	

	SLTNode* FindRet = SLTFind(&plist, 4);
	SLTErase(&plist, FindRet);
	SLTPrint(plist);
}
int main()
{
	SlistTest02();
	return 0;
}

执行结果：

2.2.10 删除pos后的节点

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//pos->next不能为空
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

因为我们要删除pos指向的节点，那么我们就得断言让pos->next不得为空，我们先创建一个指针del来保存pos的下一个节点，然后让pos指向下一个节点的下一个节点，然后将del释放掉，置为NULL。

测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	

	SLTNode* FindRet = SLTFind(&plist, 4);
	SLTEraseAfter(FindRet);
	SLTPrint(plist);
}
int main()
{
	SlistTest02();
	return 0;
}

执行结果：

2.2.11 销毁链表

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

在销毁链表，我们定义一个pcur来遍历删除各个节点，用next指针来保存pcur指向的下一个节点。直到所有节点为空完成销毁链表。

测试一下：

void SlistTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	SListDesTroy(&plist);
	
	SLTPrint(plist);
}
int main()
{
	SlistTest02();
	return 0;
}

执行结果：

这样以来我们就完成实现了链表所有接口的方法！

3. 链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：


虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构：
单链表和双向带头循环链表

1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结 构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都 是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带 来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了。

结言：下篇博客将会和大家分享单链表的oj题形。帮助各位看客姥爷可以更好的理解单链表，之后会和大家分享其他链表的实现，感谢观看。