单链表增删查改查

单链表

1.单链表的定义

单链表采用的是链式存储结构，使用一组地址任意的存储单元来存放元素，在单链表中，存放每一个数据用结点来表示，每个节点的构成为：元素+指针（存放下一个节点的地址）。

1.1 单链表结构

typedef int SLTDateType;
typedef struct  SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

在调用单链表之前，要先把链表的头指向空 SListNode* plist = NULL;

2 单链表尾插

//申请一个动态节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		printf("SListNode malloc err");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//单链表尾插
void SListPushBack(SListNode** plist, SLTDateType x)
{
	assert(plist);
	SListNode* cur = BuySListNode(x);
	if (*plist == NULL)
	{
		*plist = cur;
	}
	else
	{
		//找单链表的尾端
		SListNode* till = *plist;
		while (till ->next)
		{
			till = till->next;
		}
		till->next = cur;
	}
}

这里形参接受的是二级指针，也就是结构体的地址，一级指针也是可以操作的，只是操作起来比较繁琐，不如二级指针省事
正是因为传入的是二级指针，所以咱们这边需要使用断言assert来判断一下。
如果传入之前结构体为空，会直接赋值，如果不为空，会一直找链表的尾部，直到找到后插入x值。

2.1 单链表头插

//单链表头插
void SListPushFront(SListNode** plist, SLTDateType x)
{
	assert(plist);
	SListNode* cur = BuySListNode(x);
	if (*plist == NULL)
	{
		*plist = cur;
	}
	else
	{
		cur->next = *plist;
		*plist = cur;
	}
}

同样这里传入的是二级指针，需要断言一下
如果结构体为空会直接赋值，如果不为空，直接将新节点指向要插入的第一个节点中。

2.2单链表尾删

//单链表尾删
void SListPopBack(SListNode** plist)
{
	assert(plist);
	SListNode* till = *plist;
	if (till ->next == NULL)
	{
		free(till);
		till = NULL;
		*plist = till;
	}
	else
	{
		while (till->next->next != NULL)
		{
			till = till->next;
		}
		free(till->next);
		till->next = NULL;
	}
}

单链表尾删，新建一个找尾的结构体指针，如果单链表只有一个节点，那么直接置空，否则一直找尾节点，直到找到尾节点后再进行删除操作。

2.3 单链表头删

void SListPopFront(SListNode** plist)
{
		assert(plist);
		assert(*plist);
		SListNode* cur = *plist;
		*plist = cur->next;
		free(cur);
		cur = NULL;
}  

cur通过赋值plist的首地址然后把cur的next赋值给plist，赋值后，plist头指针为原先的next下一个，将原先的头指针释放并且置空。完成头删工作。

2.4 单链表查找

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data != x)
		{
			cur = cur->next;
		}
		else
		{
			return cur;
		}
	}
	return NULL;
}

单链表会从第一个节点的data跟x比较，如果相等，则返回相等处的节点，如果没有找到相等的会返回空

2.5 单链表pos位置之前插入

//单链表pos之前插入
void SLTInsert(SListNode** plist, SListNode* pos, SLTDateType x)
{
	assert(plist);
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	if (*plist == pos)
	{
		SListPushFront(plist, x);
		return;
	}
	SListNode* cur = *plist;
	while (cur)
	{
		if (cur->next != pos)
		{
			cur = cur->next;
		}
		else
		{
			newnode->next = pos;
			cur->next = newnode;
			return;
		}
	}
}

2.6 单链表pos位置删除

//单链表pos位置删除
void SLTErase(SListNode** plist, SListNode* pos)
{
	assert(plist);
	assert(pos);
	if (*plist == pos)
	{
		(*plist) = (*plist)->next;
		free(pos);
		pos = NULL;
		return;
	}
	SListNode* cur = *plist;
	while (cur)
	{
		if (cur->next != pos)
		{
			cur = cur->next;
		}
		else
		{
			cur->next = pos->next;
			free(pos);
			pos = NULL;
		}
	}
}

**
**

如果pos传进来为空，会被直接断言，plist也同样

2.7 单链表删除pos位置之后的值

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
	cur = NULL;
}

如果传进来的单链表只有一个参数的时候，会被直接assert断言。
将pos的next赋值给新建的结构体单链表cur，再让pos的next指向cur的next，相当于pos的下一个下一个next，巧妙地跳过了pos后一个节点，并把它释放，置空。

2.8 单链表在pos位置之后插入x

//单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

把要插入的数字赋值到新的单链表中，这个单链表只有一个节点，将新链表的next直线pos位置后一个节点，再见pos位置next直线新建的链表，完成pos位置后插。

2.9 单链表销毁

//单链表打印
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

如果cur不为空，将会一直输出data数值。

2.10 单链表销毁

//单链表销毁
void SLTDestroy(SListNode* pos)
{
	assert(pos);
	SListNode* cur = pos;
	while (cur)
	{
		SListNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

按照顺序一个一个置空