typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;//数据
	struct SListNode* next;//指向下一个结构体的指针
}SListNode;

//动态申请节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode*newnode=(SListNode*)malloc(sizeof(SListNode));//malloc空间
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;//将数据放在该节点的data
	newnode->next = NULL;//next置为空（避免野指针）
	return newnode;//返回新节点
}

//尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	//动态申请一个新节点
	SListNode* newnode = BuySListNode(x);
	//空表
	if (*pplist == NULL)
	{
		//这里改变List，传址调用、形参是实参的临时拷贝，形参的修改不会影响实参，所以传List的地址，即用二级指针变量来接收一级指针的地址，这时解引用后就会影响到List
		*pplist = newnode;
	}
	else
	{	//找尾巴
		SListNode* ptail = *pplist;
		//这里修改的是结构体成员变量，所以不用二级指针
		while (ptail->next != NULL)
		{
			ptail = ptail->next;
		}
		//将节点接在尾巴上
		ptail->next = newnode;
	}
}

//尾删
void SListPopBack(SListNode** pplist)
{
	//空表不可进行删除，所以加个断言
	assert(*pplist);
	//只有一个数据时直接把该节点释放，然后置空即可
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* ptail = *pplist;//本意即SListNode*ptail=list
		//找到最后一个的前一个
		while (ptail->next->next!=NULL)
		{
			ptail = ptail->next;
		}
		//释放最后一个节点
		free(ptail->next);
		//并把指向最后一个节点的next置空（不置空就是野指针了，因为虽然释放了那块空间，但是它的前一个节点的next依然指向它）
		ptail->next = NULL;
	}
}

//单链表打印
void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;
	//注意这里是cur！=NULL，因为假如是cur->next ！=NULL的话，最后一个节点的数据不会被打印
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL");
}

void SListTest2()
{
	SListNode* list = NULL;
	//传址调用，解引用后形参的修改会影响实参
	SListPushBack(&list, 0);
	//SListPrint(list);//0->NULL
	SListPushBack(&list, 1);
	SListPushBack(&list, 2);
	SListPushBack(&list, 3);
	SListPushBack(&list, 4);
	//打印
	//SListPrint(list);//0->1->2->3->4->NULL
	//尾删
	SListPopBack(&list);
	//SListPrint(list);//0->1->2->3->NULL
	SListPopBack(&list);
	SListPopBack(&list);
	SListPopBack(&list);
	SListPopBack(&list);
	SListPrint(list);//NULL
	//空表进行删除
	SListPopBack(&list);//报错 error
}

//头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
    //注意这里形参是二级指针，因为这里改变的是list，并不是改变list指向的结构体成员，所以传地址，而一级指针的地址，就要用二级指针pplist接收
	SListNode* newnode = BuySListNode(x);
		newnode->next =*pplist;
		*pplist = newnode;
}

//头删
void SListPopFront(SListNode** pplist)
{
	assert(*pplist);
	//先保存
	SListNode* next = (*pplist)->next;
	free(*pplist);
	*pplist = next;
}

//头插头删
void SListTest3()
{
	//头插
	SListNode* list = NULL;
	SListPushFront(&list,1);
	//SListPrint(list);//1->NULL
	SListPushFront(&list, 2);
	SListPushFront(&list, 3);
	SListPushFront(&list, 4);
	//SListPrint(list);//4->3->2->1->NULL
	//头删
	SListPopFront(&list);
	//SListPrint(list);//3->2->1->NULL
	SListPopFront(&list);
	SListPopFront(&list);
	SListPopFront(&list);
	SListPrint(list);//NULL
	//SListPopFront(&list);//error(空表不可删除)
}

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	//while (cur)
	//{
	//	if (cur->data == x)
	//	{
	//		return cur;
	//	}
	//	cur = cur->next;
	//}
	//return NULL;
	//简化版本
	while (cur && cur->data != x)
	{
		cur = cur->next;
	}
	//结束循环的条件，要么就是cur== NULL，说明找不到，或者就是cur->data==x,找到了，这里直接返回cur就行。
	return cur;
}

//在pos位置插入
void SListInsert(SListNode** pplist, SListNode* pos, SLTDateType x)
{
	if (*pplist == pos)
	{
		//头插
		SListPushFront(pplist, x);
	}
	else
	{
		SListNode* cur = *pplist;
		//找到pos节点之前的一个
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		//将新节点插入在此
		SListNode* newnode = BuySListNode(x);
		//找到了pos位置之前的了
		cur->next = newnode;
		newnode->next = pos;
	}
}

//删除pos位置
void SListErase(SListNode** pplist, SListNode* pos)
{
	assert(pos);
	//假如pos指向list
	if (pos == *pplist)
	{
		SListPopFront(pplist);
	}
	else
	{
		SListNode* cur = *pplist;
		//找到pos位置之前的
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

//单链表销毁
void SListDestroy(SListNode** pplist)
{
	SListNode* cur = *pplist;
	while(cur != NULL)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pplist = NULL;//一定要置空，不然后面打印就是野指针的访问
}