单链表详解

感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言

以下我写的一些文章,如果在阅读这篇文章过程中有疑惑的可以看一下
动态内存管理(下malloc free等函数的用法
动态内存管理(下)free空间等一些问题
自定义类型结构体(下)计算结构体内存大小的方法
自定义类型结构体(中)计算结构体内存大小的方法
自定义类型结构体(上)结构体的用法
C语言深入理解指针（非常详细）（一）指针的用法
C语言深入理解指针（非常详细）（二）指针的用法，以及野指针问题，和assert用法
C语言深入理解指针（非常详细）（三）二级指针

顺序表的问题及思考

中间/头部的插入删除，时间复杂度为O(N),效率低,但是尾部插入效率可以

增容需要申请新空间，拷贝数据，释放旧空间,且增容一般是呈2倍的增长，会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

链表

链表的概念及结构

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

由于链表不像顺序表一样要求连续，所以我们需要一种方式来管理这些数据(因为空间不一定是连续,如果不管理的话可能就找不到数据)

这种方式就是我们需要找到最开始的一块空间,然后那块空间会告诉你下一块空间的地址在哪,只有这样你才能够找到链表中的所有数据

而满足这种方式只有是通过结构体实现，结构中包含了我们想要的数据，以及下一块空间的地址

当我们所有的数据都查找完后，我们需要有人提醒我们已经找到尽头了，所以在查找完最后一块空间时，那块空间记录的下一块空间地址为空指针，也就是告诉你不需要再往后查找

链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
单向或者双向
带头或者不带头
循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了

单链表的实现

typedef int SLNDataType;
typedef struct SListNode
{
	SLNDataType val;
	struct SListNode *next;
}SLNode;

这段代码是一个结构体里装这一个数据val和一个结构体指针next(next就是为了告诉你下一块空间的地址而存在的)

很多人可能有疑惑，认为结构体还没有实现完，为什么里面就可以包含一个结构体的指针

其实结构体的指针也是指针，结构体只要定义了，知道结构体的名称就可以实现内部包含一个结构体指针

如果我们把struct SListNode* next的*去掉，就会报错

此外这里有一个问题,如何计算上面链表中一个节点所占用内存的空间,这就涉及到结构占用内存的计算,在我之前的文章中有讲过

链表功能实现

遍历链表void SLTprint(SLNode* phead)

phead为第一块空间的地址，cur是为了避免在使用链表时phead会被使用者改变,导致我们找不到第一块空间地址的指针

代码

void SLTprint(SLNode* phead)
{
		SLNode* cur = phead;
		while (cur != NULL)
		{
			printf("%d-> ", cur->val);
			cur = cur->next;
		}
		printf("NULL\n");
}

cur=cur->next是让cur去遍历链表,也就是cur指向cur的下一块节点的地址

当cur指向空时就意味着cur已经遍历完整个链表,所以直接跳出循环

链表的尾插void SLPushBack(SLNode** pphead, SLNDataType x)

链表的尾插比较麻烦,因为我们不能立马就找到最后一个节点的地址,就如之前所说的,我们想要找到节点3的地址,就需要先找到上一个节点地址,也就是节点2,因为节点3的地址是被节点2所保存的,但是节点2的地址我们也不能直接得到,所以我们只能从头节点phead开始,一个一个的去找

所以我们需要定义一个指针tail,让tail=phead,然后通过tail去寻找尾节点

那我们应该怎样才能判断已经找到了尾节点呢?

我们知道最后一个节点所保存的地址为NULL，那么如果我们用while (tail != NULL)这个条件去判断条件循环会怎么样

tail=phead时tail所指向的地址

第一次循环tail=地址2

第二次循环tail=地址3

第三次循环tail=NULL

我们可以看到用while (tail != NULL)最后是找不到尾节点的地址，所以我们需要对条件判断稍微改一下,改成while (tail->next != NULL)就可以了

然后尾插时,将3节点的NULL改成4节点的地址就可以了
按照上面的逻辑实现的代码如下

void SLPushBack(SLNode* phead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	SLNode* tail = phead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next=newnode;
}

注意这里创建的CreateNode是通过malloc创造出来的，如果我们不malloc/或者calloc的话，比如

void SLPushBack(SLNode* phead, SLNDataType x)
{
    SLNode newnode ；
	SLNode* tail = phead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next=newnode;
}

SLNode newnode 是一个局部变量，出了函数作用域就会销毁

这里我们其实少考虑了一种情况，就是如果这个链表本来就是一个空链表的话我们还需要进行判断

void SLPushBack(SLNode* phead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		SLNode* tail = phead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

这里的phead = newnode是当链表为空时,我们直接让创造出来的新节点变成链表的头结点

但是当我们运行这个函数的时候

我们发现打印不出来
我们调试来看看

我们在调试的过程中发现虽然phead被修改了,但是plist却没有被修改

这种有点像我们之前传函数参数时没有传地址的那种情况,我们给phead赋值,但是plist却没有跟着变化

所以我们怀疑phead是plist的拷贝,导致phead的改变没有影响plist

可是我们在传参的时候,传入的就是指针

其实虽然我们传入的是指针,但是我们传的指针并不对

举两个例子

void swao(int p1.p2)
{
	int tmp=p1;
	p1=p2;
	p2=tmp;
}
int a=1,b=1;
swap(a,b);

这里我们没有将a和b的地址传入函数swap中,所以函数中虽然a和b都交互了,但是由于我们传入的参数只是拷贝了a和b的值,导致出来函数作用域后,就会销毁,并没有影响到函数外的a和b

void swao(int *p1.*p2)
{
	int tmp=p1;
	p1=p2;
	p2=tmp;
}
int*p1=NULL,*p2=0x01；
swap(p1,p2);

这里的p1和p2都是指针,我们将p1和p2传入函数中,但是p1和p2在函数中的改变并不会影响函数外的p1和p2,因为我们没有传入指针的地址,我们只是传入了p1和p2这两个指针的值,也就是所这里的p1和p2就和上面的a和b相同,我们要想改变p1和p2就应该传入他们的地址

所以要想改变p1和p2我们应该这样传参

void swao(int **p1.**p2)
{
	int tmp=*p1;
	*p1=*p2;
	*p2=*tmp;
}
int*p1=NULL,*p2=0x01；
swap(&p1,&p2);

注意因为p1和p2是int*类型,所以函数swap传入的参数类型也应该变成int**,而swap(&p1,&p2)则是将这两个指针的地址传入函数中
我们将传入的地址解引用,*p1就是对p1的地址解引用结果为NULL，*p2就是对p2的地址解引用结果就是0x01

代码

void SLPushBack(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

创造新节点SLNode* CreateNode(SLNDataType x)

因为对于链表创建节点是非常常见的一种操作,所以我们单独拿出来写成一个函数

代码

SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

链表头插void SLPushFront(SLNode** pphead, SLNDataType x)

链表的头插就相对来说比较简单了,我们不需要像尾插一样将整个链表遍历一遍,只不过我们需要注意在头插的时候不能直接就让pphead=newnode,因为这样就会找不到之前pphead的地址

所以我们需要让newnode->next=pphead,然后让pphead=newnode

代码

void SLPushFront(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

注意这段代码已经是解决了链表为空的情况了,因为当链表为空是,pphead=NULL，然后让newnode->next=pphead（也就是newnode=NULL）,然后pphead=newnode

链表尾删void SLPopBack(SLNode** pphead)

方法一

链表的尾删需要注意的是我们在找到尾节点的同时,尾节点是不能直接free掉的,因为尾节点的上一个节点的next仍然指向了尾节点,所以我们还需要将尾节点的上一个节点指向的地址改为NULL，因为我们同时需要尾节点的地址还有尾节点前一个的地址，所以我们选择用两个指针prev和tail，prev指向tail的前一个节点，当tail->next指向空时,tail就指向了尾节点,而prev也就指向了尾节点的前一个节点

具体过程如图,每次tial走到下一个节点时,就赋值给prev





我们还需要考虑到链表只有一个节点的情况,如果按照上面的逻辑会出现问题(就是prev初始化的问题)

如果prev初始化为*pphead,那么就会出现下面的情况

当tail->next为空时,tail不往后走，然后我们free(tail)时,prev仍然是指向尾节点,导致prev成了一个野指针

所以我们需要加一个条件判断if(（*pphead）->next==NULL）,然后直接free掉这个节点(这里的
*pphead加了一个括号是因为优先级的问题)，并且对prev初始化成NULL

如果链表已经没有任何节点,但是还有人继续删除链表,这样是不行的,所有我们需要提醒链表已经删除完了,不能再删除

代码

void SLPopBack(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);//空链表不能删除,所有要断言*pphead
	if (*pphead == NULL)
	{
		printf("链表已无节点可删\n");
		return;
	}
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
    }
}

方法二

方法二就是不用两个指针，我们只需要找到尾节点的前一个节点就可以了
通过tail->next->next去找,当tail->next->next=NULL的时候就意味着tail已经在尾节点的前一个位置
然后我们就释放tail->next所指向的空间,让tail->next=NULL

代码

void SLPopBack(SLNode** pphead)
{ 
	assert(pphead);
	assert(*pphead);
	if (*pphead == NULL)
	{
		printf("链表已无节点可删\n");
		return;
	}
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
    }
}

链表头删void SLPopFront(SLNode** pphead)

头删和尾删非常的相似，我们只需要将先判断如果只有一个节点时，我们就直接将节点删除，当有多个节点的时候，我们就可以想用一个指针tail去保存头节点，不然我们头删后，找不到之前头节点的下一个节点，，然后让*pphead=（*pphead）->next,之后就可以释放tail指向的空间了



下面一段代码是一种错误示范

void SLPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode*tail=*pphead;
	free(tail);
	*pphead=(*pphead)->next;
}

当free(tail)后我们无法从头结点中找到下一个节点,可能会有人认为free(tail)只是free掉tail这个指针,其实free掉的是这个指针指向的空间

所以我们要在free掉这个空间之前找到节点的下一个地址,就可以解决这个问题,我们只需要互换位置就可以了

void SLPopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode*tail=*pphead;
	*pphead=(*pphead)->next;
	free(tail);
}

代码

void SLPopFront(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead );
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
	}
	else
	{
		SLNode* tail = *pphead;
		*pphead = (*pphead)->next;
		free(tail);
		tail = NULL;
	}
}

还有一种就是让tail指向下一个节点,然后释放pphead指向节点的空间,再用tail给pphead赋值

void SLPopFront(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead );
		SLNode* tail = (*pphead)->next;
		free(*pphead);
		*pphead=tail;
}

链表的查找SLNode* SLFind(SLNode* phead, SLNDataType x)

我们用指针cur去遍历这个链表，如果cur的数据val值是和x想等的，那么就直接返回cur这个位置的节点，如果cur->val!=x,那么我们就让cur走到下一个节点cur=cur->next,当遍历完整个链表后我们还是没有找到和x相等的val,那么我们就直接返回一个NULL就行了

代码

SLNode* SLFind(SLNode* phead, SLNDataType x)
{
	assert(pphead);
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

链表任意位置前插入void SLInsert(SLNode**pphead，SLNode* pos, SLNDataType x)

函数功能为在pos位置前插入链表数据x

在实现这个函数之前，有一个问题，就是pphead和*pphead的区别

pphead是一个二级指针，所有pphead表示对所一级指针的地址，也就是指向链表头节点指针的地址
*pphead是对pphead解引用，表示指向链表头节点的指针，注意不是指向链表头节点指针的地址

那么我们知道了这两个都区别，我们再来看看下面这个问题

pphead *pphead pos这三个是否需要断言

首先pphead断言 assert（pphead）表示我们要检查指向链表头节点指针的地址是否为空，换句话说就是如果传入为空，这个函数是否会出现问题，显然，如果我们传入为空，那么我们就无法找到指向链表头节点指针，

那*pphead断言assert（*pphead）就表示我们要检查链表头节点指针是否指向的空，如果指向空，就代表这个链表为空链表，我们就可以当这个函数为头插，或者尾插，所有这并不会对这个函数造成影响

pos断言assert（pos）表示传入参数插入位置指针的地址是否为空，如果为空，那么我们也就找不到插入的位置，所以pos是需要断言的
但是有一种情况pos只能为空，就是*pphead为空，空链表我们要插入的地址当然只能传空，为了防止这种情况我们就需要像这样断言 assert((!(*pphead) == !pos) || pos && *pphead)

!(*pphead) == !pos)表示pos为空时为假，pphead为空时也为假，通过！对两个取反，使假变成真
pos && pphead表示pos和pphead都不为空
这两个只需要满足其中的一个就可以继续用插入函数
当pos和pphead二者中只有一个为空时就会断言报错

还有一种情况就是pos的位置根本不在链表中，我们整个链表都找完了，就是没有找到pos的位置，所有我们要判断当链表遍历完时，仍然没有找到pos的位置，我们就需要提醒一下找不到pos的位置

代码

void SLInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	assert(pphead);
	assert((!(*pphead) == !pos) || pos && *pphead);
	if ((*pphead == pos))//头插情况
	{
		SLPushFront(pphead, x);
	}
	else {
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			if (prev->next == NULL)
			{
			printf("找不到pos的位置");
				exit（-1）;
			}
			prev = prev->next;
		}	
		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

链表任意位置前删除void SLErase(SLNode**pphead，SLNode* pos)

函数功能为删除pos位置的节点
这个函数和之前的函数实现方式都是差不多的,删除一个节点,就需要找到这个节点的前一个节点

void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		if (prev->next == NULL)
		{
			printf("找不到pos的位置");
			exit(-1);
		}
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

这个代码过程如下图

prev->next=pos

让prev->next=pos->next

释放pos指向节点的空间

上面的代码还是少考虑了只有一个节点时的情况
prev->next为空,但是prev已经在pos所在的位置了

我们就应该加一个判断,if(*pphead=pos),然后就直接头删

代码

void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLPopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			if (prev->next == NULL)
			{
				printf("找不到pos的位置");
				exit(-1);
			}
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

链表任意位置后插入void SLInsertAfter( SLNode* pos,SLNDataType x)

之前是在pos位置之前插入,我们需要遍历链表才能找到pos位置之前的节点,所以需要传pphead,而这个函数是在pos位置后插入,所有就不需要传pphead

void SLInsertAfter( SLNode* pos,SLNDataType x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	pos->next = newnode;
	newnode->next = pos->next;
}

这是一段错误的代码



我们发现按照上面的逻辑pos->next其实就是newnode->next,所以在用这个函数时就会出现问题

代码

void SLInsertAfter( SLNode* pos,SLNDataType x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

例题

用void SLInsertAfter( SLNode* pos,SLNDataType x)实现在pos位置前插入一个节点
思路:虽然我们不知道pos位置前一个节点的地址,但是我们可以通过这个函数在pos位置后插入一个节点,然后让这个节点的数据val和pos位置的数据val交换,就可以实现这pos位置之前插入节点

链表任意位置后删除void SLEraseAfter(SLNode* pos, SLNDataType x)

我们来看看下面一段代码

void SLEraseAfter(SLNode*pos)
{
	assert(pos);
	pos->next=pos->next->next;
	free(pos->next);
}

这段代码有人认为程序运行的过程如下

其实是这样的

这段代码不仅没有删除pos的下一个节点,反而让pos下一个节点的next指针变成了野指针

正确的方法是需要用tail指针保存pos->next,然后让pos->next=pos->next->next,之后再释放掉tail指向的空间

void SLEraseAfter(SLNode* pos, SLNDataType x)
{
	assert(pos);
	SLNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

但是我们还需要考虑到pos为尾节点的情况,因为pos->next=NULL，而pos->next->next就不知道是什么了,所以我们还需要加一下断言

代码

void SLEraseAfter(SLNode* pos, SLNDataType x)
{
	assert(pos);
	assert(pos->next);
	SLNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

销毁链表void SLDestroy(SLNode** pphead)

代码

void SLDestroy(SLNode** pphead)
{
	assert(pphead);
	SLNode* cur = *pphead;
	while (cur != NULL)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}