单链表（不含哨兵位）

单链表的定义

        定义：单链表是一种线性数据结构，其中的每个元素都包含数据和指向下一个元素的指针。这种存储是非连续的，它主要通过指针来将元素链接。

单链表的实现

单链表打印

该函数主要是用来遍历单链表并且打印

void SLTPrint(SLTNode* phead)
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur->next)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("%d\n",cur->data);
}

先使用assert断言该链表不为空，如果为空则没有打印的必要。

创建一个cur指针来指向链表的头节点（我们一般不适用phead来遍历，这不符合常识并且phead可能需要再次赋值给其他），通过cur指针来遍历我们的链表。先打印数据再使cur指向下一个数据的地址。

单链表节点创建

SListNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc failed!\n");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

该部分被抽取出来形成一个函数，提升代码复用。

用newnode来存储创建的地址，然后检测是否创建成功，并且初始化该节点并且返回。

单链表尾部插入

void SListPushBack(SListNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

首先调用BuySListNode函数来创建一个节点。如果这个链表是空的，直接将newnode给予*pphead；如果不为空，则直接让链表的尾部元素的next存储newnode的地址。

思考：为什么形参不是SListNode*pphead

因为形参的改变并不会影响实参，因此我们使用二级指针或者使用引用。

其实我们在有些OJ中我们还喜欢设定一个tail，来让它一直指向尾部，从而不需要每次都遍历一遍。

单链表尾部删除

void SListPopBack(SListNode** pphead)
{
	assert(pphead);
	assert(*pphead);//空链表不能尾部删除，所以一定需要断言一下*pphead！
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* cur = *pphead;
		SListNode* prev = cur;
		while (cur->next!=NULL)
		{
			prev = cur;
			cur = cur->next;
		}
		free(cur);
		prev->next = NULL;
	}
}

单链表为空的时候不能进行尾部删除，直接用assert断言一下。if ((*pphead)->next == NULL)的目的就是判断是否该链表只有它一个节点，即就一个头节点，如果是我们直接进行释放和置空；如果不是那么我们需要找到尾部节点之前一个节点和尾部节点，然后释放尾部节点并将其前面一个节点的next置空，不然会有野指针的问题。

单链表头部插入

void SListPushFront(SListNode** pphead, SLTDataType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

创建一个新的节点，然后让它的next指向*pphead，并且让newnode成为头节点。

单链表头部删除

void SListPopFront(SListNode** pphead)
{
	assert(pphead); 
	assert(*pphead);
	SLTNode* head = *pphead;
	*pphead = head->next;
    free(head);
	head = NULL;
}

同样，单链表为空我们不能进行删除。我们需要定义一个head来方便我们释放这个头节点，不然会发生内存泄漏，最后将head置空。

单链表查找元素

SListNode* SListFind(SListNode* phead, SLTDataType x)
{
	SListNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

这个函数返回值是SListNode*，这是为了和后面的函数一起联合使用。找到返回该节点的地址，如果找不到返回NULL。

在目标位置后插入

void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

让newnode的next指向pos位置的next，然后让pos的next指向newnode。

在目标位置后删除

void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
	//注意pos->next指向的空间被释放，注意在函数调用处将传值的ret置空。
}

pos不能为NULL并且pos的下一位也不能为空（即不能删尾部节点），所以直接断言。同样定义一个SListNode*的变量来方便后面释放目标节点。

在目标位置前插入

void SListInsertBefore(SListNode** phead, SListNode* pos, SLTDataType x)
{
	if (*phead == NULL)
	{
		SListNode* newnode = BuySListNode(x);
		*phead = newnode;
	}
	else
	{
		SListNode* cur = *phead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SListNode* newnode = BuySListNode(x);
		cur->next = newnode;
		newnode->next = pos;
	}
}

如果链表为空，那么直接将newnode赋值给*phead；如果不为空，则需要先找到pos前一个位置的节点，使其的next存储newnode地址，再newnode的next存储pos的地址。

删除目标节点数据

void SListErase(SListNode** pphead, SListNode* pos)
{
    assert(*pphead);
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		*pphead = (*pphead)->next;
		free(pos);
		pos = NULL;
	}
	else
	{
		SListNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
	//最后注意将传值给pos的指针置空
}

同样该我们需要断言该链表不为空且pos不为空。如果删除位置为头节点，让其头节点后移，直接free掉pos，然后置空；如果不是头节点，那我们需要找到pos位置的前一个位置让其next存储pos的next存储的地址，然后释放并置空pos。

单链表销毁

void SListDestroy(SListNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* temp = cur->next;
		free(cur);
		cur = temp;

	}
	*pphead = NULL;
}

遍历一遍单链表并且逐步释放即可。

总结

如果在pos位置前or头部插入或者删除我们时间复杂度略高一点，因此我们一般推荐pos后插入或者尾插，但链表的空间利用率高，不像顺序表可能存在空间的浪费。你需要多少空间，链表就开多少空间。