单链表的增删查改

什么是单链表：

定义：单链表是由一个个节点组成的，而节点又是由存储的数据（可以是整型，浮点型，结构体类型等等）和指向下一个节点的指针所组成的单向不循环无头链表。（这里的无头指的是没有哨兵位的链表）。

typedef int SLTDataType;
typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;
}SLTNode;//表示节点

这里将int重定义为SLTDataType，方便以后存储其他类型（若要修改只需将第一行的int修改）。将struct SListNode重定义为SLTNode方便以后使用。

单链表的操作：

创建链表：

        初始化一个链表：

既然链表是由一个个节点组成的那么先用malloc函数创建4个节点作为例子。

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;

在这里先创建了4个节点作为一个链表，最后创建一个结构体指针plist指向了第一个节点。

上图是创建出来的一个单链表，这里的箭头是人为想象出来方便理解的实际上是不存在的。

新增一个节点：

//创建新的节点，x为值
SLTNode* SLTBuyNode(SLTDataType x)
{
	//malloc一个新节点取名为newnode
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//进行判断，如果malloc失败则警告
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	//对新节点newnode进行初始化
	//值为x，指向下一个节点的指针为空
	newnode->data = x;
	newnode->next = NULL;
	//返回
	return newnode;
}

在以下代码中创建一个新节点就直接调用SLTBuyNode函数了。

单链表的增：

        尾插：

进行尾插的时候先创建一个新节点，然后将这个节点尾插在链表最后。

首先要了解尾插所需要的形参，需要一个二级指针和一个存储的数

                                                       SLTNode** pphead     SLTDataType x

那么为什么需要二级指针呢？

在一个函数中，改变形参并不能影响实参，如果只是传一个节点的指针，那么改变这个指针在返回后这部分并不能保留，而导致影响不了我的初始链表，所以要传一个指向一个节点中指向下一个节点的指针的地址（用二级指针来接收），下面用一个简单的例子来类比：

如图所示，如果我在一个函数中改变a并不能影响到主函数中的a。

那么要如何解决呢？

如上图所示：

我们只需传a的地址，在函数中进行解引用操作，那么就可以改变a的值了。

我要想改变a，要传a的地址

那么如果想要改变a的地址，则要传a的地址的地址。

那么回到我们的链表中：

我要想改变链表中一个节点的地址，那么就要传指向这个节点中指向下一个节点的指针的地址，那么就要用二级指针来接收。

OK，形参没问题了，那么看我们函数中的逻辑。

一个链表可能初始化时有值，也可能初始化时没有值也就是一个空链表，

那么对空链表进行尾插的时候就需要判断一下，

如果是空链表，那么直接将指向第一个节点的指针指向新的节点，

否则进行找尾节点进行尾插。

找尾节点的方法：先定义一个ptail指向node1，接着遍历链表，

结束条件为：ptail->next   != NULL

那么此时ptail指向最后一个节点，

在进行改链表

OK，思路没问题直接开写：

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	//首先传过来的指针一定不能为空所以可以断言一下
	assert(pphead);
	//创建一个新的节点
	SLTNode* newnode = SLTBuyNode(x);
	//*pphead是指向第一个节点的指针
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else {
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next != NULL)
		{
			ptail = ptail->next;
		}
		//此时ptail 指向尾节点
		ptail->next = newnode;
	}
}

如果你理解以上了，那么接下来的都是对你小菜一碟了，

都是差不多的，通过画图把改的指针想清楚就行了。

头插：

头插基本和尾插一样，只需在最前面改两个指针

★注意：这里的顺序不能换，如果换了，那么就会找不到节点1。

OK，思路一出直接开写：

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

在指定位置之前插入数据：

在指定位置之前插入数据有两种情况：

1、这个指定位置在第一个节点

那么只需调用上面的头插即可

2、这个指定位置在其他节点

那么先定义一个指向node1的指针，在遍历链表，

结束条件：这个指针的下一个节点为所指定的位置

注意：不能传空指针所以进行断言

同样：顺序不能交换。

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	//新建一个节点
	SLTNode* newnode = SLTBuyNode(x);
	if (pos = *pphead)//指定位置在node1
	{
		SLTPushFront(pphead, x);//头插
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//改变节点中的地址
		newnode->next = pos;
		prev->next = newnode;
	}
}

在指定位置之后插入数据：

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

单链表的删：

        尾删：

尾删有两种情况：

1、链表只有一个节点

只需释放该节点即可

2、链表有多个节点，删最后一个，然后将上一个节点指向最后一个节点的指针置空

这里是将prev->next置空

思路：

先定义两个指针指向node1，

然后让ptail找到最后一个节点，

遍历时让prve紧跟ptail就可以找到删除最后一个节点后，新链表的最后一个节点，将这个新的节点置空就行。

OK！思路一出直接开写：

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else {
		//链表有多个节点,删最后一个
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
		//ptail->next = NULL;//这里最后一个节点已经删除了，ptail已经free了，NULL->next 空指针访问
		//不需要把这个next再置为空了
	}
}

头删：

头删先找到第二个节点，

然后释放第一个节点，

再将plist指向第二个节点使其成为新的头节点

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;//这里因为->的优先级高于*所以要用（）来先算*再算->
	free(*pphead);
	*pphead = next;
}

删除pos节点：

思路：

先定义一个新指针（prev）指向第一个节点，

然后遍历链表，

结束条件：prev->next  != pos

出循环后将prev->next 指向 pos->next

在释放pos，置空pos即可

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;

	free(pos);
	pos = NULL;
}

删除pos之后的节点：

思路：

定义一个新指针（del）指向pos的后一个节点，

将pos指向del的下一个节点，

释放del，置空del。

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);

	SLTNode* del = pos->next;
	pos->next = del->next;

	free(del);
	del = NULL;
}

链表的销毁：

遍历这个链表，进行销毁：

先定义一个新指针（pcur）指向第一个节点，

然后再进循环，

结束条件为：pcur为空则跳出循环，

再循环里面定义一个指针指向pcur的下一个节点，

再释放pcur，让pcur指向next

最后将最开始的指针置空。

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

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

单链表的查找：

思路：

查找不需要改变链表，所以只需传一级指针即可，还有一个参数为待查找的数字

先定义一个新指针指向的一个节点，

遍历该链表，

如果等于x则返回指向x的指针（pcur），否则返回空

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

单链表的修改：

若要修改单链表中的一个节点

创造一个函数SListChangeDate

两个参数：SLTNode* phead（通过SLTFind函数来找到需要修改的数据x），修改的数据y。

1、先用SLTFind函数找到需要改的节点

2、在直接在SListChangeDate函数中修改

void SListChangeData(SLTNode* phead, SLTDataType y)
{
	assert(phead);

	SLTNode* cur = phead;
	cur->data = y;

}

测试代码：

void SListTest()
{
	//初始化链表
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPrint(plist);
	SLTPushBack(&plist, 2);
	SLTPrint(plist);
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	//测试尾删
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//
	//测试头删
	/*SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);*/

	//找到值为3的节点
	SLTNode* find = SLTFind(plist, 3);

	//测试删除在find之后的节点
	//SLTEraseAfter(find);
	//SLTPrint(plist);

	//测试修改
	//这是将值为3的节点修改为30
	SListChangeData(find , 30);
	SLTPrint(plist);
}