数据结构篇：线性表的另一表达—链表之单链表(下篇)

目录

1.前言

2.是否使用二级指针

3.插入/删除

[3.1 pos位置前/后插入](#3.1 pos位置前/后插入)

[3.2 查找函数](#3.2 查找函数)

[3.3 pos位置删除](#3.3 pos位置删除)

[3.4 pos位置后面删除](#3.4 pos位置后面删除)

[3.5 函数的销毁](#3.5 函数的销毁)

4.断言问题

[4.1 断言pphead](#4.1 断言pphead)

[4.2 断言*pphead](#4.2 断言*pphead)

5.三个文件的代码

[5.1 头文件](#5.1 头文件)

[5.2 具体函数实现](#5.2 具体函数实现)

[5.3 测试用例](#5.3 测试用例)

---

1.前言

之前是讲述了单链表的头插尾插，头删尾删函数部分，并且揭示了链表相对于顺序表的优势性。更重要的是对于next的理解和对二级指针的理解 ，为什么在单链表中用一级指针报错而要用二级指针，其实简单的说就是看会不会改变指针指向。

2.是否使用二级指针

在单链表中，无论是尾插还是尾删。尾插的时候，在第一次插入元素的时候，没有节点，头节点是一个指向为空 。实参那里一开始的链表初始化为空，是一个NULL。要尾插的时候，通过函数来改变外部的这个phead的指向，这个实参plist是一个一级指针，如果要通过函数来改变这个一级指针的指向，就是要传二级指针，也就是一级指针的地址。

头插的时候，传的是二级指针，因为和尾插一样，每次头插都要改变头节点的指向。

尾删的时候，删到最后一个节点，它就会改变头节点的指向，仔细想，删除最后一个节点删没了，头节点这个时候指向应该指向空，所以也是要二级指针才能改变。

---

结论就是看这个头节点会不会变，如果会变的话，就用二级指针 ，如果不变，那就不用传二级指针。

3.插入/删除

3.1 pos位置前/后插入

和顺序表一样 ，链表也是可以在中间某个位置pos前/后插入的，而且在特殊位置，比如在第一个位置前插入，那等同于头插 。那么就可以把头插的函数复用就可以了。思路是：定义一个前指针这里用former，找到pos的前一个位置，怎么找呢，有next这个节点，只要former的next不是pos的地址，就一直遍历，直至找到。然后former的next指向新节点，新节点的next再指向pos。(相当于把former和pos之间的指针断开了，重新进行了指向)，这是pos位置前插入的思路图：
pos位置前插入

测试用例如下：找到3的位置，然后在3的位置前插入7
测试用例

当然也可以有头插的效果，在判断该位置是否是头节点后，如果是，就复用头插函数。

void SLTinsert(SLTnode** pphead,SLTnode*pos, Sltdatatype x)
{
	assert(pos);
	assert(pphead);
	//如果pos是第一个，就等于头插
	if (pos == *pphead)
	{
		//复用头插函数
		SLTpushfront(pphead,x);
	}
}

测试当然也是成功的：

pos位置后面插入，也是同理，先查找，是否有该位置存在，有就给出一个返回值。然后进行插入，那么既然在第一个位置前插入数据等同于头插，那在最后一个位置后插入，是什么，应该是尾插吧。

思路就是找到pos后，先用一个next的指针保存原来pos的next，然后pos的next指向newnode，也就是新节点，最后新节点的next再指向保存原来pos的next的那个next指针。有点小绕，但画个图就明白了。保存是为了更方便点。这是顺序的从左到右依次连接。

或者不那么绕，前者是pos->newnode->pos的下一个，形成了中间插入。也可以newnode->posd的next，pos->newnode。从后往前连接，就可以不用定义指针去保存pos的下一个节点。代码会少一两行。这里我选用第二种方法

void SLTinsert_afterpos(SLTnode** pphead,SLTnode *pos, Sltdatatype x)
{
	assert(pphead);
	assert(pos);
	SLTnode* newnode = insertSLTnode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

3.2 查找函数

在上文中，我们要在pos位置插入，和顺序表一样，也是需要先找到该位置才能进行插入，需要有个返回值，然后再调用插入函数。而查找函数思路也很简单，只需要遍历链表，找到是否有data等于x的值就可以，没有就返回NULL。

SLTnode* SLTfind(SLTnode* pphead, Sltdatatype x)
{
	//遍历
	SLTnode* cur = pphead;
	while (cur)
	{
		if (cur->data==x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

3.3 pos位置删除

经过pos位置的前后插入练习，其实pos位置的删除，pos位置后的删除思路也是很明确了。正确掌握好链表的位置关系，以及对next的理解，就基本没什么问题。删除pos位置，也就是意味着要把pos的前后连起来，并且释放掉pos位置。那么就需要有一个former指针，该指针的next指向pos的next，就可以了。思路图如下：

特殊情况：如果要删除的位置是头节点，也就是头删，同样复用头删函数。

void SLTErase(SLTnode** pphead, SLTnode* pos)
{
	assert(pphead);
	assert(*pphead);
	if (pos == *pphead)
	{
		SLTpopfront(pphead);
	}
	else
	{
		SLTnode* former = *pphead;
		while (former->next != pos)
		{
			former = former->next;
		}
		former->next = pos->next;
		free(pos);
	}
}

3.4 pos位置后面删除

紧接着来看pos位置后删除，这里同pos位置后插入一样，有两种写法，一种是pos的next指向pos的next的next，就是跳过了中间的数据，因为中间的数据是要被删除的。最后释放掉pos后面的位置就行。

---

或者用一个有意义的名字定义个指针，该指针把要删除的数据保存下来，pos的next和该指针的下一个连接起来就可以。两者其实没有本质区别的。

void SLTerase_afterpos(SLTnode** pphead, SLTnode* pos)
{
	assert(pos->next);
	SLTnode* erase = pos->next;
    pos->next = pos->next->next;
	free(erase);
	erase = NULL;
	
}

之前的案例是在3的后面插入一个7，那么这次把7删掉，就是可以用到pos后面删除数据。

3.5 函数的销毁

由于我们申请的空间都是malloc出来，在堆上申请的，那根据malloc的特质，我们需要需要把它销毁掉并且置空，防止内存泄露的问题出现。

销毁的思路就是，把链表存放到一个指针中（cur）（这里不需要改变指针的指向，只是改变结构体的内容，所以只需要一级指针 ），用另一个指针next去保存当前节点的下一个，先释放保存链表数据的cur指针，然后指针内容更新为节点的下一个 ，循环到链表为空。这里没有进行置空，是因为函数的形参不改变实参，所以里面置空不影响外部函数链表的结果，一级指针改变不了一级指针的内容，如果要在里面更改就要传递二级指针。所以我传的是一级指针，在外部置空。

void SLTdestory(SLTnode * phead)
{
	SLTnode* cur = phead;
	while (cur)
	{
		SLTnode* next = cur->next;
		free(cur);
		cur=next;
	}
}

4.断言问题

在写单链表的过程中，每个函数是否要断言，断言哪些地方，是需要考虑的，不能一刀切，结合实际情况实际考虑的。

4.1 断言pphead

首先断言的情况是pphead传入的是链表地址，链表的地址传错了的话是NULL会发生报错，那么我们要断言的情况，就是防止有空的误传进来（比如没有取地址）。所以链表地址一定不为空。

4.2 断言*pphead

*pphead，是链表的内容，看*pphead有没有可能为空，如果这个值在某个情况下不应该是空，那么我们就可以断言，因为不可能为空的，一定有数值的传进来，结果你断言后报错了，说明传进来的有问题啊。如果这个函数允许有空的存在，那么不需要断言，因为断言了不就传不进来，就与初衷有悖。

---

举个例子，插入的时候，*pphead有没有可能为空，空链表能插入，说明可以为空，为空你加assert(*pphead)，那不是铁铁报错吗。空链表能打印，能插入，不用断言 。空链表不能尾删，不能头删，要断言 ，为空还删什么。但是pphead要断言，它是链表的地址，它一定铁定不为空。所以一定要*pphead断言。

结论是： 所以有个思维就是如果这个值绝对不为空，那么我们就可以断言。而且断言会直接报错，告诉你错在哪里，根据场景去灵活变通，发现基本错误，调试的成本，花费的时间要远比断言来的高。在这里pphead一定不为空，*pphead看场景。具体情况具体分析。

5.三个文件的代码

这里展示头文件，具体函数和测试用例的全部代码。

5.1 头文件

#pragma once
#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);
SLTnode* insertSLTnode(Sltdatatype x);
void SLTpushback(SLTnode** pphead, Sltdatatype x);
void SLTpopback(SLTnode** pphead);
void SLTpushfront(SLTnode** pphead, Sltdatatype x);
void SLTpopfront(SLTnode** pphead);
SLTnode* SLTfind(SLTnode* pphead, Sltdatatype x);
//pos之前插入
void SLTinsert(SLTnode **pphead,SLTnode*pos,Sltdatatype x);
//pos位置删除
void SLTErase(SLTnode** pphead, SLTnode* pos);
//pos后面插入
void SLTinsert_afterpos(SLTnode**phead,SLTnode* pos,Sltdatatype x);
//pos后面删除
void SLTerase_afterpos(SLTnode** pphead, SLTnode* pos);
//链表销毁
void SLTdestory(plist);

5.2 具体函数实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"
SLTnode* insertSLTnode(Sltdatatype x)
{
	//申请一块空间给新的节点
	SLTnode* newnode = (SLTnode*)malloc(sizeof(SLTnode));
	if (newnode == NULL)
	{
		perror("fail malloc");
		return 0;
	}
	newnode->data = x;

	newnode->next = NULL;

	return newnode;
}
//尾插
void SLTpushback(SLTnode **pphead,Sltdatatype x)
{
	assert(pphead);
	SLTnode* newnode = insertSLTnode(x);
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	//找尾
	else
	{
		//定义尾变量
		SLTnode* tail = *pphead;
		while (tail->next!=NULL)
		{
			tail = tail->next;
			
		}
		//tail->next这个指针指向新节点
		tail->next= newnode;
	}
}

//尾删
void SLTpopback(SLTnode** pphead)
{
	//检查
	assert(pphead);
	assert(*pphead);
	//一个节点
	if ((*pphead)->next==NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//多个节点
	else
	{
		// 找尾
		SLTnode* former = NULL;
		SLTnode* tail = *pphead;
		while (tail->next != NULL)
		{
			former = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;
		former->next = NULL;
	}
}
void SLTprint(SLTnode* phead)
{
	SLTnode* cur = phead;
	while (cur)
	{
		printf("%d ",cur->data);
		cur=cur->next;
	}
	printf("NULL\n");
}

//头插
void SLTpushfront(SLTnode** pphead, Sltdatatype x)
{
	assert(pphead);
	SLTnode* newnode = insertSLTnode(x);
	//把newnode的下一个给pilst
	newnode->next = *pphead;
	//链表指针指向新节点，变成新的头部
	*pphead =newnode;
}
//头删
void SLTpopfront(SLTnode** pphead)
{
	assert(pphead);
	assert(*pphead);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	
	//第一个节点的地址，给到first这个指针
		SLTnode* first = *pphead;
		//plist指向first的下一个地址，就是第二个节点
		*pphead = first->next;
		free(first);
		//删除第一个
		first = NULL;
}
SLTnode* SLTfind(SLTnode* pphead, Sltdatatype x)
{
	//遍历
	SLTnode* cur = pphead;
	while (cur)
	{
		if (cur->data==x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void SLTinsert(SLTnode** pphead,SLTnode*pos, Sltdatatype x)
{
	assert(pos);
	assert(pphead);
	//如果pos是第一个，就等于头插
	if (pos == *pphead)
	{
		//复用头插函数
		SLTpushfront(pphead,x);
	}
	else
	{
		SLTnode* former = *pphead;

		if (former->next!=pos)
		{
			former = former->next;
		}
		SLTnode* newnode = insertSLTnode(x);
		former->next = newnode;
		newnode->next = pos;
	}
}
void SLTErase(SLTnode** pphead, SLTnode* pos)
{
	assert(pphead);
	assert(*pphead);
	if (pos == *pphead)
	{
		SLTpopfront(pphead);
	}
	
	else
	{
		SLTnode* former = *pphead;
		while (former->next != pos)
		{
			former = former->next;
		}

		former->next = pos->next;
		free(pos);
	}
	
}
void SLTinsert_afterpos(SLTnode** pphead,SLTnode *pos, Sltdatatype x)
{
	assert(pphead);
	assert(pos);
	SLTnode* newnode = insertSLTnode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}



void SLTerase_afterpos(SLTnode** pphead, SLTnode* pos)
{
	assert(pos->next);
	SLTnode* erase = pos->next;
pos->next = pos->next->next;
	free(erase);
	erase = NULL;
	
}


void SLTdestory(SLTnode * phead)
{
	SLTnode* cur = phead;
	while (cur)
	{
		SLTnode* next = cur->next;
		free(cur);
		cur=next;

	}
}

5.3 测试用例

void test7()
{
	SLTnode* plist = NULL;

	SLTpushback(&plist, 1);
	SLTpushback(&plist, 2);
	SLTpushback(&plist, 3);
	SLTpushback(&plist, 4);
	SLTpushback(&plist, 5);
	SLTprint(plist);
	SLTnode* ret = SLTfind(plist, 3);
	SLTinsert_afterpos(&plist,ret,7);
	SLTprint(plist);

	SLTerase_afterpos(&plist, ret);
	SLTprint(plist);
	SLTdestory(plist);
	plist = NULL;
}
int main()
{
	
	test7();
	return 0;
}

单链表的复习和讲解就到这里了 ，单链表一开始学习还是比较晦涩难懂的，但是写多了，错误多了，坑踩多了，就会熟悉里面的内容了。还是要多理解，多做题，后面也会讲解一些单链表的O经典J题来加强印象。多做题也是熟悉链表的一个很好的方式！