#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

void TestSList1()
{
	SLTNode* plist = NULL;
	//尾插 
	//当某次尾插之前的plist如果为NULL,在调用函数内要改变*pplist,所以要使用传址调用,由于此时的plist初始化为NULL,所以当第一次尾插的时候一定要使用
	//传址调用,这是因为要在调用函数内部改变*pplist的值,如果按照下面的代码来看的话,连续进行尾插，第二次以及后面的尾插时,已经保证前面有了节点,这时按理说是可以通过传值调用即可,但是,还要再写出来
	//另外一个尾插函数，这是因为第一次尾插时必须传址,若后面的尾插采用传值的话,调用函数的形参部分就要发生改变,写出来两个尾插函数,比较麻烦,
	//其二就是,如果不是连续调用尾插函数的话,两次尾插之间如果有别的函数存在时,可能其他函数会改变*pplist的值,当再次尾插时,就不知道*pplist是否为NULL,要先进行判断,如果为NULL则使用传址调用,如果不为空,则使用传值,
	//这样就会非常麻烦,所以当每次尾插时都使用传址调用即可,这是因为传址调用能够满足传值调用的要求,但是传值满足不了传址调用的要求、
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	//头插
	//每一次头插的时候,在调用函数内部都需要改变*pplist,所以要使用传址调用、
	SListPushFront(&plist, 0);
	//打印
	//打印时不会在调用函数内部改变*pplist的值,所以直接传值调用即可、
	SListPrint(plist);
	//尾删
	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//尾删
	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//尾删

	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//尾删

	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//尾删
	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//尾删
	SListPopBack(&plist);
	//打印
	SListPrint(plist);
	//头删
	SListPopFront(&plist);
	//打印
	SListPrint(plist);

	//尾插
	SListPushBack(&plist, 1);
	//尾插
	SListPushBack(&plist, 2);
	//尾插
	SListPushBack(&plist, 3);
	//打印
	SListPrint(plist);
	//头删
	SListPopFront(&plist);
	//打印
	SListPrint(plist);

	//查找附带修改、
	SLTNode* pos = SListFind(plist, 2);
	if (pos == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		printf("找打了,其地址为:%p\n", pos);
		//查找功能附带修改功能、
		//pos->data = 30;
		//修改后进行打印、
		//printf("修改完之后进行打印为:\n");
		//SListPrint(plist);
		//单链表在pos位置之 后 插入数据200;

		SListInsertAfter(pos, 200);
		//打印
		SListPrint(plist);
		//单链表在pos位置之 前 插入数据300;
		SListInsertBefore(&plist, pos, 300);//传址
		//打印
		SListPrint(plist);
		//单链表删除pos位置之 后 的节点、
		SListEraseAfter(pos);
		//打印
		SListPrint(plist);
	}
	//尾删
	SListPopBack(&plist);
	//尾删
	SListPopBack(&plist);
	//打印
	SListPrint(plist);

	//查找附加修改、
	pos = SListFind(plist, 300);
	if (pos == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		printf("找打了,其地址为:%p\n", pos);
		//查找功能附带修改功能、
		//pos->data = 30;
		//修改后进行打印、
		//printf("修改完之后进行打印为:\n");
		//SListPrint(plist);

		//单链表删除pos所在位置的节点、
		SListEraseCur(&plist, pos);
		//打印
		SListPrint(plist);
	}

	//尾插
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);

	//打印
	SListPrint(plist);

	//查找附加修改、
	pos = SListFind(plist, 5);
	if (pos == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		printf("找打了,其地址为:%p\n", pos);
		//查找功能附带修改功能、
		//pos->data = 30;
		//修改后进行打印、
		//printf("修改完之后进行打印为:\n");
		//SListPrint(plist);

		//单链表删除pos所在位置的节点、
		SListEraseCur(&plist, pos);
		//打印
		SListPrint(plist);
	}
	//尾插
	SListPushBack(&plist,6);
	//打印
	SListPrint(plist);

	//销毁单链表、
	SListDestroy(&plist);
	//打印
	SListPrint(plist);
}

int main()
{
	TestSList1();

	return 0;
}

//单链表结构适合头插,头删,  尾部若进行插入或删除是不适合的,对于尾插要进行遍历找尾,尾删的时候还要遍历找到倒数第二个节点的地址,然后
//再将其next置为空指针NULL,若在pos位置之前插入节点也是不方便的,需要先遍历找到pos位置之前的节点的地址,除此之外,删除pos位置所在的节点也是不方便的
//需要找到pos位置前面的一个节点的地址,使其与pos所在位置之后的节点或者空指针NULL链接起来、

//使用双向链表单独存储数据会更加方便，单链表主要用来作为复杂数据结构的子结构,如:图的邻接表或者是哈希桶、
//除此之外,单链表会在很多经典的练习题中使用、

3.3.2、SList.c源文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"


//打印链表
void SListPrint(SLTNode* plist)
{
	//在此处不可以直接断言plist,因为,链表可能为空链表,当链表为空链表的时候,打印出来就是空链表,只有NULL
	//若在此处对plist进行断言,如果链表为空链表的话,在此就会直接报错,而我们想要的是,若链表为空链表时,就打印出空链表,而不是直接报错、

	//在调用函数内部没改变 plist 的值,所以选用  传值  调用、
	SLTNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		//链表的遍历、
		cur = cur->next;
	}
	printf("NULL\n");
}


//创建新节点
SLTNode* BuySLTNode(SLTDataType x)
{
	//在堆区上按需索取空间、
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		//动态开辟空间失败、
		printf("malloc fail\n");
		return NULL;
	}
	else
	{
		//动态开辟内存空间成功、
		node->data = x;
		node->next = NULL;
		return node;
	}
}

//尾插
void SListPushBack(SLTNode** pplist, SLTDataType x)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//创建新节点、
	SLTNode* newnode = BuySLTNode(x);

	//判断 *pplist是否为空、
	if (*pplist == NULL)
	{
		//空链表、
		//在调用函数内部改变了*pplist的值,所以选用 传址 调用、
		*pplist = newnode;
	}
	else
	{
		//非空链表、
		//先遍历链表进行找尾、
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
//当使用带头链表进行尾插时,即使链表为空,此时链表中还有头节点,其不存有效数据,而plist就指向了该头节点的地址,所以plist不是空指针NULL
//当进行尾插时,直接在头节点后面进行链接节点即可,所以进行尾插时直接使用 传值 调用即可、


//头插
void SListPushFront(SLTNode** pplist, SLTDataType x)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//创建新节点、
	SLTNode* newnode = BuySLTNode(x);

	//不需要考虑 *pplist 是否为空指针,在此,不管其是否为空指针NULL,都是可以的、
	newnode->next = *pplist; 
	//在调用函数内部改变了*pplist的值,所以选用 传址 调用、
	*pplist = newnode;
}
//当使用带头链表进行头插时,不是在头节点前面插,而是在所有的有效节点之前,头节点之后进行插入,此时plist仍指向的是头节点的地址,并没有被改变,所以
//直接使用传值调用即可、



//尾删
void SListPopBack(SLTNode** pplist)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);


	//也可以暴力检查链表为空的情况,当链表为空的时候就代表不能再进行尾删了,若再尾删就会报错、
	//assert(*pplist);

	//下面情况是非暴力检查,其代表当链表为空的时候,是可以进行尾删的,不会报错,只不过没有删掉任何节点,当再打印链表的时候
	//还是打印出空链表就行了、
	if (*pplist == NULL)
	{
		//链表中没有节点、
		//没有节点可以删除,所以就直接返回即可、
		return;
	}
	else if ((*pplist)->next == NULL)
	{
		//只有一个节点、
		//当有节点存在时,不管是以哪种方法删去,只要删除一个节点则就需要释放一个空间,但是由于此种情况只有一个节点,而且*pplist指向了第一个节点的地址,若把该空间释放后,那么*pplist所指的空间就再存在,则该指针即为野指针
		//所以要将其置为空指针NULL,此时就需要改变*pplist的值,只有通过传址调用才能使得调用函数外面的*pplist的值发生改变,所以在此选择 传址 调用、
		free(*pplist);
		//在调用函数内部改变了*pplist的值,所以选用 传址 调用、
		*pplist = NULL;
	}
	else
	{
		//多个节点、

		//记录倒数第二个节点的地址,通过该节点的地址,找到并把该节点中指针所指的地址置为NULL;
		//方法一:
		SLTNode* prev = NULL;
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		//此时tail是一个局部变量,当free(tail)后再把tail置为空指针的原因是因为,当释放完空间之后,tail仍指向这块空间的地址,此时指针变量tail即为
		//野指针,为了防止不小心再次对该野指针进行解引用从而造成错误,所以就要将其置为空指针NULL,这是一个好习惯,此时即使不把指针变量taile置为空指针
		//NULL也是可以的,这是因为指针变量tail是一个局部变量,当出了调用函数后则局部变量就会被销毁,在调用函数外部是无法使用局部变量tail的,所以即使
		//再此不把tail置为空指针也是可以的,但是一般来说都置为空指针,这是一个好习惯、
		prev->next = NULL;


		方法二：
		//SLTNode* tail = *pplist;
		//while (tail->next->next != NULL)
		//{
		//	tail = tail->next;
		//}
		此时tail所在位置即为倒数第二个节点的地址、
		//free(tail->next);
		//tail->next = NULL;
	}
}
//当使用带头链表进行尾删时,即使链表全部删完,此时链表中还有头节点,头节点不会被删除,其不存有效数据,而plist就指向了该头节点的地址
//由于该头节点所占空间不会被释放,所以不需要把plist置为空指针NULL,所以当进行尾删时直接使用 传值 调用即可、



//头删
//每一次头删,当不是空链表时,plist的值就会发生改变,所以要使用传址调用,当是空链表时直接返回,虽然没有改变*pplist的值,但是为了使用同一个
//调用函数,直接使用 传址 调用即可、
void SListPopFront(SLTNode** pplist)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//也可以暴力检查链表为空的情况,当链表为空的时候就代表不能再进行尾删了,若再尾删就会报错、
	//assert(*pplist);

	//下面情况是非暴力检查,其代表当链表为空的时候,是可以进行头删的,不会报错,只不过没有删掉任何节点,当再打印链表的时候
	//还是打印出空链表就行了,在OJ题中一般都是不采取暴力的、

	if (*pplist == NULL)
	{
		//空链表、
		//不再需要删除,直接返回即可、
		return;
	}
	else
	{
		//链表中一个或多个节点、

		//对于链表而言,如果直接把前一个节点释放掉的话,则后一个节点的地址就会被置为随机值,即,如果直接释放掉前一个节点的话,就找不到后一个节点了
		//所以,在释放前一个节点之前先把后一个节点的地址保存一份、

		//保存下一个节点的地址、
		//-> 的优先级高于 *
		SLTNode* next = (*pplist)->next;
		free(*pplist);
		//在调用函数内部改变了*pplist的值,所以选用 传址 调用、
		*pplist = next;
		//当链表中只有一个节点时,则结构体指针变量next中存储的就是空指针NULL,现要释放*pplist所指的空间,之后则指针变量*pplist就变成了
		//野指针,要将其置为空指针NULL,此时,结构体指针变量next的值就是空指针NULL,将其赋值给*pplist,则就会把*pplist置为空指针NULL、
	}
}



//查找附加修改、
SLTNode* SListFind(SLTNode* plist, SLTDataType x)
{
	//当链表为空时,plist等于NULL,此时查找的话想得到的结果就是找不到即可,并不需要直接断言从而报错,太暴力、
	//assert(plist);

	//该调用函数返回值为查找到的节点的地址、
	//在调用函数内部没有改变plist的值,则只需要 传值 调用即可、
	SLTNode* cur = plist;
	//如果为空链表,则plist等于NULL,所以,cur等于NULL,不进循环、
	//如果不是空链表,则进入循环、
	while (cur)	
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	//到此为止,只有两种情况,要么是空链表不进入循环从而没找到,要么就是进入循环遍历完链表之后也没有找到、
	return NULL;
}
//像查找和打印一样的功能,使用的都是传值调用,在这两个调用函数内部,按理说也可以不进行SLTNode* cur = plist; 直接使用plist即可,这是因为,两个调用函数
//采用的都是传值调用,形参是实参的一份临时拷贝,在调用函数内部改变形参不会改变实参的值,所以在调用函数内部直接使用plist也是可以的,即使改变了它的值,在调用函数
//外部的plist的值仍没有发生改变,但是通常进行SLTNode* cur = plist操作,是一种好的习惯,并其代码的可读性较高,但是如果采用的是传址调用的话,这里就不能不进行赋值操作
//否则在调用函数内部改变plist的值,调用函数外部的plist的值也会随之改变、




//单链表在pos位置之后插入x;
//在调用函数内部不会改变pos的值,故 传值 调用即可、
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	//不需要通过在调用函数内部改变pos的值从而改变外面的pos的值,所以直接 传值 调用即可、

	//断言,保证pos位置的地址是有效的、
	assert(pos);
	//在此也可以不对pos进行断言,具体见  单链表在pos位置之 前 插入x 里面、
	//个人感觉这一步也可以省略是因为,如果程序能够执行到该调用函数的话,说明了pos一定不等于空指针NULL,若等于空指针根本就不能执行该调用函数,所以这一部省略也是可以的
	//加上也不影响,同时当调用到该函数时,pos一定不是空指针NULL,,那么又间接说明了链表肯定不是空链表,所以综合下来只需要进行第一个断言即可,加上pos的断言也是没有关系的、
	//这是鉴于在main函数里已经把关系捋清楚之后的情况,即把SListEraseCur,SListEraseAfter,SListInsertBefore,SListInsertAfter函数的调用放在找到pos的模块内,即pos不等于NULL模块内是可以省略pos的断言
	//但是如果在main函数内没有把这些调用函数放在其中的话,就需要断言一下pos防止出现问题,所以,我们在这里最好要进行断言一下才会更加安全、

	//当代码执行到该调用函数时,pos一定不是空指针NULL,所以其一定是有效地址,所以pos一定指向链表中有效节点的地址、

	//创建新节点、
	SLTNode* newnode = BuySLTNode(x);

	//方法一:
	/*newnode->next = pos- >next;
	pos->next = newnode; */

	//方法二:
	//在把新节点插入链表中之前把pos位置的下一个节点的地址保存一份到next中、
	SLTNode* next = pos->next;
	pos->next = newnode; 
	newnode->next = next;
}


单链表在pos位置之 前 插入x;
//void SListInsertBefore(SLTNode* pos, SLTDataType x)
//{
//	不需要通过在调用函数内部改变pos的值从而改变外面的pos的值,所以直接 传值 调用即可、

//	//断言,保证pos位置的地址是有效的、
//	assert(pos);

//	//创建新节点、
//	SLTNode* newnode = BuySLTNode(x);
//	
//	//此时,可以通过:newnode->next=pos,,这样就可以把新节点与pos位置的节点进行链接起来,但是,新节点要想与原来pos位置的前一个节点链接
//	//起来是不容易的,因为,pos位置的前一个节点的地址是不知道的,又因是单链表,所以也无法通过后一个节点推出前一个节点的地址,所以目前来看
//	//pos位置的前一个节点的地址是不知道的,就没有办法把pos位置的前一个节点与新节点进行链接、
//	//这就是单链表的缺陷,如果是双链表的话,就可以直接通过pos找到pos位置的前一个节点的地址了,所以,使用单链表在pos位置之前插入数据是比较麻烦的、
//
//	//但是使用单链表的话也是可以解决的,只不过比较麻烦,现在就是不知道pos位置的前一个节点的地址,所以要想办法去寻找,只能从单链表起始位置一直找才可以,
//	//所以该调用函数的形参部分要进行改动,我们要从单链表的起始位置开始往后找节点,那么就需要在该调用函数的形参部分来接收指向单链表起始位置（第一个节点）的指针。
//}


//单链表在pos位置之 前 插入x;
void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//断言,保证pos位置的地址是有效的、
	assert(pos);
	//个人感觉这一步也可以省略是因为,如果程序能够执行到该调用函数的话,说明了pos一定不等于空指针NULL,若等于空指针根本就不能执行该调用函数,所以这一部省略也是可以的
	//加上也不影响,同时当调用到该函数时,pos一定不是空指针NULL,,那么又间接说明了链表肯定不是空链表,所以综合下来只需要进行第一个断言即可,加上pos的断言也是没有关系的、
	//这是鉴于在main函数里已经把关系捋清楚之后的情况,即把SListEraseCur,SListEraseAfter,SListInsertBefore,SListInsertAfter函数的调用放在找到pos的模块内,即pos不等于NULL模块内是可以省略pos的断言
	//但是如果在main函数内没有把这些调用函数放在其中的话,就需要断言一下pos防止出现问题,所以,我们在这里最好要进行断言一下才会更加安全、

	//可以暴力检查链表为空的情况,这是因为,已经默认当调用该函数时链表不可能为空,但是当*pplist为空指针NULL时说明肯定出现了错误,可以暴力检查、
	//assert(*pplist);
	//这一步可以省略,是因为前面已经断言了pos,当前面pos的断言通过之后,间接的断言了链表不是空链表,所以可以省略这一步、

	//该调用函数是用来在pos位置之前插入数据x,当执行到该调用函数时,pos的值肯定不是空指针NULL,这个时候那么链表肯定是不空链表,
	//所以在此不考虑链表为空的情况、

	//不需要通过在调用函数内部改变pos的值从而改变外面的pos的值,所以直接 传值 调用即可、


	//当pos的位置恰好为第一个节点的位置时,此时pos等于cur,不进入循环,出循环再执行prev->next = newnode;的时候
	//由于此时的prev中还是空指针NULL,所以就会出错,所以要加if语句过滤,如果pos的位置恰好为第一个节点的位置时就相当于是头插,


	方法一:

	创建新节点、
	//SLTNode* newnode = BuySLTNode(x);

	判断pos所在的位置是否为第一个节点、
	//if (pos == *pplist)
	//{
	//	//pos所在位置是第一个节点的位置、

	//	//头插即可、
	//	newnode->next = pos;
	//	//在调用函数内部会改变*pplist的值所以要选择 传址 调用、
	//	*pplist = newnode;
	//}
	//else
	//{
	//	//pos所在位置不是第一个节点的位置、
	//	SLTNode* prev = NULL;
	//	SLTNode* cur = *pplist;
	//	while (cur != pos)
	//	{
	//		prev = cur;
	//		cur = cur->next;
	//	}
	//	prev->next = newnode;
	//	newnode->next = pos;
	//}


	//方法二:
	//判断pos所在的位置是否为第一个节点、
	if (pos == *pplist)
	{
		//pos所在位置是第一个节点的位置、
		//头插即可、
		SListPushFront(pplist, x);
	}
	else
	{
		//pos所在位置不是第一个节点的位置、
		SLTNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//创建新节点、
		SLTNode* newnode = BuySLTNode(x);
		newnode->next = pos;
		prev->next = newnode;
	}
}
//但是如果不告诉指向单链表的起始位置(第一个节点)的指针应该怎么办呢？
//应该先在pos所在位置的后面插入一个新的节点,插入完毕后,再把新节点和pos所在位置的节点中的data进行交换即可、


//单链表删除pos位置之 后 的节点、
void SListEraseAfter(SLTNode* pos)
{
	//不需要通过在调用函数内部改变pos的值从而改变外面的pos的值,所以直接 传值 调用即可、

	//断言,保证pos位置的地址是有效的、
	assert(pos);
	//个人感觉这一步也可以省略是因为,如果程序能够执行到该调用函数的话,说明了pos一定不等于空指针NULL,若等于空指针根本就不能执行该调用函数,所以这一部省略也是可以的
	//加上也不影响,同时当调用到该函数时,pos一定不是空指针NULL,,那么又间接说明了链表肯定不是空链表,所以综合下来只需要进行第一个断言即可,加上pos的断言也是没有关系的、
	//这是鉴于在main函数里已经把关系捋清楚之后的情况,即把SListEraseCur,SListEraseAfter,SListInsertBefore,SListInsertAfter函数的调用放在找到pos的模块内,即pos不等于NULL模块内是可以省略pos的断言
	//但是如果在main函数内没有把这些调用函数放在其中的话,就需要断言一下pos防止出现问题,所以,我们在这里最好要进行断言一下才会更加安全、

	//也可以暴力检查pos所在位置后面是否为空的情况,当为空的时候就代表不能再删除了,若再尾删就会报错、
	//assert(*pplist);

	//也可以进行温柔检查,当pos所在位置后面为空时,则不需要删除直接返回就行,不让其报错、

	//当代码执行到该调用函数时,pos一定不是空指针NULL,所以其一定是有效地址,所以pos一定指向链表中有效节点的地址、

	//判断pos所在位置后面是否还有节点、
	if (pos->next == NULL)
	{ 
		//pos所在位置后面没有节点、
		//不需要删除,直接返回即可、
		return;
	}
	else
	{
		//pos所在位置后面有节点,无论是pos所在位置后面有一个还是多个节点时均适用、
		SLTNode* next = pos->next;
		pos->next=next->next;
		free(next);
		next = NULL;
	}
}



//单链表删除当前pos所在位置的节点、
void SListEraseCur(SLTNode** pplist, SLTNode* pos)
{
	//不需要通过在调用函数内部改变pos的值从而改变外面的pos的值,所以直接 传值 调用即可、

	//该调用函数是用来删除pos所在位置的节点,当执行到该调用函数时,pos的值一定不是空指针NULL,这个时候那么链表肯定是不空链表,所以在此不考虑链表为空的情况、

	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//断言,保证pos位置的地址是有效的、
	assert(pos);
	//个人感觉这一步也可以省略是因为,如果程序能够执行到该调用函数的话,说明了pos一定不等于空指针NULL,若等于空指针根本就不能执行该调用函数,所以这一部省略也是可以的
	//加上也不影响,同时当调用到该函数时,pos一定不是空指针NULL,,那么又间接说明了链表肯定不是空链表,所以综合下来只需要进行第一个断言即可,加上pos的断言也是没有关系的、
	//这是鉴于在main函数里已经把关系捋清楚之后的情况,即把SListEraseCur,SListEraseAfter,SListInsertBefore,SListInsertAfter函数的调用放在找到pos的模块内,即pos不等于NULL模块内是可以省略pos的断言
	//但是如果在main函数内没有把这些调用函数放在其中的话,就需要断言一下pos防止出现问题,所以,我们在这里最好要进行断言一下才会更加安全、

	//可以暴力检查链表为空的情况,这是因为,已经默认当调用该函数时链表不可能为空,但是当*pplist为空指针NULL时说明肯定出现了错误,可以暴力检查、
	//assert(*pplist);
	//这一步可以省略,是因为前面已经断言了pos,当前面pos的断言通过之后,间接的断言了链表不是空链表,所以可以省略这一步、


	//方法一:
	//如果pos的位置恰好为第一个节点的位置时就相当于是头删、
	//判断pos所在的位置是否为第一个节点、
	if (pos == *pplist)
	{	
		//pos所在位置是第一个节点的位置、
		//头删即可、

		//链表中有一个或多个节点、
		//对于链表而言,如果直接把前一个节点释放掉的话,则后一个节点的地址就会被置为随机值,即,如果直接释放掉前一个节点的话,就找不到后一个节点了
		//所以,在释放前一个节点之前先把后一个节点的地址保存一份、
		//保存下一个节点的地址、
		//-> 的优先级高于 *
		SLTNode* next = (*pplist)->next;
		free(*pplist);
		//在调用函数内部改变了*pplist的值,所以选择 传址 调用、
		*pplist = next;
		//当链表中只有一个节点时,则结构体指针变量next中存储的就是空指针NULL,现要释放*pplist所指的空间,之后则指针变量*pplist就变成了
		//野指针,要将其置为空指针NULL,此时,结构体指针变量next的值就是空指针NULL,将其赋值给*pplist,则就会把*pplist置为空指针NULL、
	}
	else
	{
		//pos所在位置不是第一个节点的位置、
		SLTNode* prev = NULL;
		SLTNode* cur = *pplist;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		//无论pos所在位置后面有节点,还是没有节点的情况均适用、
		prev->next = pos->next;
		free(pos);
		pos= NULL;
		//当pos的位置恰好为第一个节点的位置时,此时pos等于cur,不进入循环,出循环再执行prev->next = newnode;的时候
		//由于此时的prev中还是空指针NULL,所以就会出错,所以要加if语句过滤,如果pos的位置恰好为第一个节点的位置时就相当于是头删、
	}


	方法二:
	如果pos的位置恰好为第一个节点的位置时就相当于是头删、
	判断pos所在的位置是否为第一个节点、
	//if (pos == *pplist)
	//{
	//	//pos所在位置是第一个节点的位置、
	//	//头删即可、
	//	SListPopFront(pplist);
	//}
	//else
	//{
	//	//pos所在位置不是第一个节点的位置、
	//	SLTNode* prev = *pplist;
	//	while (prev->next != pos)
	//	{
	//		prev = prev->next;
	//	}
	//	//无论pos所在位置后面有节点,还是没有节点的情况均适用、
	//	prev->next = pos->next;
	//	free(pos);
	//	pos = NULL;
	//}
}




//销毁单链表(释放空间)、
void SListDestroy(SLTNode** pplist)
{
	//即使链表为空链表,即结构体指针变量plist为空指针NULL，但是结构体指针变量plist的 地址 一定不是空指针NULL,并且该结构体指针变量
	//plist的地址一定不能是空指针NULL,若为空指针NULL,下面对其解引用,即*pplist相当于对空指针NULL进行解引用,会出现错误、
	assert(pplist);

	//当链表为空链表时,链表中没有节点,就不需要对节点进行释放,此时*pplist为空指针NULL,所以指针变量cur也是空指针NULL,不进入循环,
	//再把空指针NULL赋值给*pplist,程序结束、

	//注意,此时不要对*pplist进行断言,若为空链表时不需要直接报错,只是不对任何节点进行释放空间即可,只需要使得*pplist置为空指针NULL即可，但不需要直接报错、

	//链表一个一个的对节点进行释放、
	SLTNode* cur = *pplist;
	while (cur != NULL)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//在调用函数内部改变了*pplist的值,所以选择 传址 调用、
	*pplist = NULL;
}

3.3.3、SList.h头文件：

#pragma once
#include
#include
#include

//存储数据的载体叫做节点,一个节点中至少要有一个数据域和一个指针域,前一个节点里的指针域中的指针变量指向下一个节点、

//单链表、
//在顺序表中,一上来就直接有一个结构体,即使顺序表中一个值也没有,那么也要存在一个结构体,结构体中的结构成员变量的值都是随机值
//所以要对其进行初始化,而对于链表而言,在最初的时候,如果是空链表,即没有一个节点时,此时是没有结构体的,只有一个指针变量，当需要往
//链表中链接节点的时候,就需要创建新的节点(结构体)并对其结构体成员变量进行赋值,所以，链表不需要进行初始化、

//单向不带头不循环
//定义一个节点、
typedef int SLTDataType;

typedef struct SListNode
{
	//数据域
	SLTDataType data;
	//指针域,该节点中指针域中的指针变量指向下一个节点,一个节点就是一个结构体、
	struct SListNode* next;//在这里一定不要把struct SListNode*写成SLTNode*、
}SLTNode; 

//链表也是线性表,也要关注增删查改、

//尾插
void SListPushBack(SLTNode** pplist, SLTDataType x);


//头插
void SListPushFront(SLTNode** pplist, SLTDataType x);


//尾删
void SListPopBack(SLTNode** pplist);



//头删
void SListPopFront(SLTNode** pplist);


//打印
void SListPrint(SLTNode* plist);


//查找附加修改、
SLTNode* SListFind(SLTNode* plist, SLTDataType x);


//单链表在pos位置之 后 插入x、			
void SListInsertAfter(SLTNode* pos, SLTDataType x);


单链表在pos位置之 前 插入x、
//void SListInsertBefore(SLTNode* pos, SLTDataType x);

//单链表在pos位置之 前 插入x、
void SListInsertBefore(SLTNode** pplist,SLTNode* pos, SLTDataType x);


// 单链表删除pos所在位置之后的节点、
void SListEraseAfter(SLTNode* pos);


// 单链表删除当前pos所在位置的节点、
void SListEraseCur(SLTNode** pplist,SLTNode* pos);


//销毁单链表
void SListDestroy(SLTNode** pplist);



双链表、
定义一个节点、
//struct ListNode
//{
//	//数据域
//	int data;
//	//指针域,该节点中指针域中的指针变量指向下一个节点,一个节点就是一个结构体、
//	struct SListNode* next;
//	//指针域,该节点中指针域中的指针变量指向上一个节点,一个节点就是一个结构体、
//	struct SListNode* prev;
//};

3.4、链表面试题：