单链表专题

针对顺序表，我们会发现顺序表会有一些问题，比如中间/头部插入效率低下，增容降低运行效率，增容造成空间浪费等，为了解决这些问题，可以应用单链表来解决。

单链表的创建

链表，顾名思义，就是要将各个节点串联在一起，所以，单链表的节点就需要有两个组成部分，一个是数据部分，一个是存储下一个节点的地址的指针部分。最后一个节点存储的地址就是空指针NULL。

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

单链表的打印

想要打印单链表，就需要遍历单链表，应用while循环，循环结束的条件就是节点的next指针为NULL。

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;

	while (pcur)//pcur!=NULL
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

单链表节点的创建

当我们想要在链表中插入数据时，就需要先创建一个节点，然后再将数据插入节点中。我们应用malloc来申请内存，内存申请成功后，再将数据插入节点中，并将next指针置为NULL。

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode*newnode= (SLTNode*)malloc(sizeof(SLTNode));

	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

单链表的尾插

想要在单链表尾部插入一个节点，首先需要先创建一个新节点，然后需要应用while循环找到单链表的尾节点，循环结束的条件是节点的next的指针为NULL。再将尾节点的next指针指向刚刚申请的新节点。

void SLTPushBack(SLTNode* phead, SLTDataType x)
{
	//申请节点
	SLTNode* newnode = SLTBuyNode(x);
    //找尾
    SLTNode* ptail = phead;
    while (ptail->next)
    {
	    ptail = ptail->next;
    }
    //ptail指向的就是尾节点
    ptail->next = newnode;
}

再考虑一下当链表为空链表时是否能够正常插入。我们会发现，当链表为空链表时，并不能顺利插入，所以需要分为空链表与非空链表两种条件。

void SLTPushBack(SLTNode* phead, SLTDataType x)
{
	//申请节点
	SLTNode* newnode = SLTBuyNode(x);
	//需要考虑在插入新节点时该单链表是否为空链表

	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = phead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//ptail指向的就是尾节点
		ptail->next = newnode;

	}
}

单链表的传值传址问题

但是当我们进行插入测试时，发现数据并没有插入到链表中，进行调试后发现，是传值与传址的问题。当我们传入的是指向单链表第一个节点的指针时，并没有改变单链表中的数据。所以我们应当传的是指向单链表第一个节点的指针的地址，这样就可以解决这个问题了。

//第一个节点                   *plist    **pphead
//指向第一个节点的指针          plist     *pphead
//指向的一个节点的指针的地址   &plist      pphead

//尾插（正确版）

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//空链表与非空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}

单链表的头插

相较于尾插，头插就容易很多。我们只需要新建一个节点，再将节点的next指针与单链表的头节点连接在一起就好了。

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

单链表的尾删

尾删首先需要先找出单链表的尾节点，将尾节点释放后再将新的单链表的尾节点的next指针置为NULL。想要实现，就需要新设置两个指针均指向单链表的头节点，当找到尾节点后，利用其中一个指针释放尾节点，利用另一个指针将尾节点的next指针置为空。

当我们实现了这个代码后，试验一下当链表只有一个节点的时候是否能够符合该代码。不符合则需要判断链表是否只有一个节点，如果只有一个节点，则直接释放就可以了。

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead && pphead);
	//链表只有一个节点
	if ((*pphead)->next==NULL)
	{
		free(*pphead);
		*pphead == NULL;
	}
	//链表有多个节点
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;

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

单链表的头删

想要实现单链表的头删，只需要把指向单链表的第一个节点的指针指向第二个节点，并将第一个节点释放掉。

void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead && pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

单链表的查找

因为只是在链表中查找数据，并不会改动链表的数据，所以只需要传指向单链表的指针就可以了。然后使用while循环遍历单链表，查找到数据则返回该链表的地址，若没有找到，则返回空指针。

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

单链表在指定位置之前插入数据

首先需要判断是否是在单链表的第一个节点之前插入数据，如果是的话，则可以直接调用头插的函数。如果是在其他位置插入数据，我们需要先创建一个新节点用来存储数据，接下来应用while循环来遍历链表，找到指定位置，在找到指定位置后，先将新节点与指定节点链接，再将指定节点的前一个节点与新节点链接。

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

	//当*pphead=pos时证明是头插
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

单链表在指定位置之后插入数据

因为是在指定位置之后插入数据，所以我们不需要遍历链表寻找指定位置之前的节点。只需要新建一个节点存储数据，再将新节点与指定节点下一个节点连接，再将指定节点与新节点连接就可以了。

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	
	newnode->next = pos -> next;
	pos->next = newnode;
}

删除pos节点

首先我们需要判断pos节点是不是头节点，如果是则可以直接调用头删的函数。如果是任意节点，则需要将pos节点的前一个节点与pos节点的后一个节点进行连接。所以需要应用while循环遍历链表找到pos节点的前一个节点。

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(*pphead && pphead);
	assert(pos);
	//pos是头节点
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	//pos不是头节点
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

删除pos节点后面的节点

首先需要先判断pos节点和pos指向的next节点均不能为空指针。然后如果我们应用

pos->next->next指针去找的话，我们就会找不到下下个节点。所以我们需要新建一个指针del去存储需要删除的节点,通过del->next去找pos节点的下下个指针。将pos节点与pos节点的下下个节点连接后，就可以释放掉pos后面的节点了。

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

销毁链表

销毁链表就是应用while循环遍历链表，逐个释放节点，为了防止节点释放后找不到下一个节点，我们需要新设置一个指针用来存储下一个节点。

void SListDestroy(SLTNode** pphead)
{
	assert(*pphead && pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}