无头单向不循环链表详解

---

链表介绍

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表的不同分类：
1.带头、不带头

2.单向、双向

3.循环、非循环

通过以上的这些情况组合起来，就有八种链表结构。即带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。

本篇博客讲解的是无头单向非循环链表。

初始化链表

链表是由一个个结点链接而成，创建一个链表之前，我们首先要创建一个结点类型，该类型由两部分组成：数据域和指针域。

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

打印链表

打印链表时，我们需要从头指针指向的位置开始，依次向后打印，直到指针指向NULL时，结束打印。

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

销毁链表

由于链表都是在堆区申请的内存，因此在不使用的时候，应该对它进行释放，否则会造成内存泄漏，释放的时候需要一个变量来保存next的地方。

void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

增加节点

仔细想想，每当我们需要增加一个结点之前，我们必定要先申请一个新结点，然后再插入到相应位置，于是我们可以将该功能封装成一个函数。

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

单链表的头插

头插时，我们只需要先让新结点的指针域指向头指针指向的位置（即原来的第一个结点），然后让头指针指向新结点即可。

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

单链表的尾插

尾插的时候我们需要先判断链表是否为空，若为空，则直接让头指针指向新结点即可；若不为空，我们首先需要利用循环找到链表的最后一个结点，然后让最后一个结点的指针域指向新结点。

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	//1、空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}

	//2、非空
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)//找尾
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

在给定位置之后插入

在给定位置后插入结点也只需要两步：先让新结点的指针域指向该位置的下一个结点，然后再让该位置的结点指向新结点即可。

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

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

在给定位置之前插入

要想在给定位置的前面插入一个新结点，我们首先还是要找到该位置之前的一个结点，然后让新结点的指针域指向地址为pos的结点，让前一个结点指向新结点即可。需要注意的是，当给定位置为头指针指向的位置时，相当于头插。

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

	
	if (*pphead == pos)
	{
		SListPushFront(pphead, x); 
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;

			//暴力检查,pos不在链表中,prev为空，还没有找到pos
			assert(prev);
		}

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

删除节点

单链表的头删

头删较为简单，若为空表，则不必做处理；若不为空表，则直接让头指针指向第二个结点，然后释放第一个结点的内存空间即可。

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);//暴力检查

	if (*pphead != NULL)
	{
		SLTNode* del = *pphead;
		*pphead = (*pphead)->next;
		free(del);
		del = NULL;
	}
}

单链表的尾删

尾删相对麻烦一些，我们需要考虑三种不同的情况：

1、当链表为空时，不做处理。
2、当链表中只有一个结点时，直接释放该结点，然后将头指针置空。
3、当链表中有多个结点时，我们需要先找到最后一个结点的前一个结点，然后将最后一个结点释放，将前一个结点的指针域置空，使其成为新的尾结点。

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);//暴力检查

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}

	else
	{
		//两种方式

		//1、
		/*SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;*/

		//2、
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;

		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = NULL;
		free(tail);
		tail = NULL;
	}
}

删除给定位置之后的节点

要删除给定位置之后的值，我们首先判断传入地址是否为最后一个结点的地址，若是，则不做处理，因为最后一个结点后面没有结点可删除。若不是最后一个结点，我们首先让地址为pos的结点指向待删除结点的后一个结点，然后将待删除结点释放即可。

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);//确保传入地址不为空
	if (pos->next == NULL)//判断传入地址是否为最后一个结点的地址
	{
		return;
	}
	SLTNode* after = pos->next;//待删除的结点
	pos->next = after->next;//让pos结点指向待删除的结点的下一个结点
	free(after);//释放结点
	after = NULL;//及时置空
}

删除给定位置的节点

要删除给定位置的结点，我们首先要判断该结点是否为第一个结点，若是，则操作与头删相同；若不是，我们就需要先找到待删除结点的前一个结点，然后让其指向待删除结点的后一个结点，最后才能释放待删除的结点。

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);//确保传入地址不为空
	if (pos == *pphead)//判断待删除的结点是否为第一个结点
	{
		*pphead = pos->next;//让头指针指向第二个结点
		free(pos);//释放第一个结点
		pos = NULL;//及时置空
	}
	else
	{
		SLTNode* prev = *pphead;//接收头指针
		while (prev->next != pos)//找到待删除结点的前一个结点
		{
			prev = prev->next;
			//检查pos不是链表中的节点，参数传错了
			assert(prev);
		}
		prev->next = pos->next;//让待删除的结点的前一个结点指向待删除结点的后一个结点
		free(pos);//释放待删除结点
		pos = NULL;//及时置空
	}
}

查找数据

查找数据相对于前面的来说就非常简单了，我们只需要遍历一遍链表，在遍历的过程中，若找到了目标结点，则返回结点的地址；若遍历结束也没有找到目标结点，则直接返回空指针。

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