动态单链表（C语言）

本次我们将用代码完成一个动态的单链表，首先我们先建立好工程，本次单链表实现，头文件为：SList.h，源文件为：SList.c以及Test.c。

其中，我们将函数的声明和库函数的应用都放入到SList.h中，将函数的内容放入到SList.c中，Test.c中放置main函数用于调试。

我们本次要实现的单链表形态如下：

所以单链表中的每个个体都需要包含一个int和一个指针指向下一个int，为此我们将其打包成为一个结构体：

接下来我们根据单链表的形成过程来思考我们需要的函数。首先：蓝标的组成单位是节点，所以我们需要一个函数去申请节点，于是我们编写一个函数：BuySListNode，其中我们需要向新的节点中赋予一个int类型，所以我们的形参为SLTDateType    （int）

动态申请一个内存空间，我们在这里使用malloc函数来申请一个大小为sizeof(SListNode)的空间，并且检查是否申请成功，如果失败则停止，成功则赋值。

将节点的申请完成后，因为我们需要将前后节点连接起来才能形成一个链表，所以我们需要一个函数来进行尾插任务，其中我们需要对链表进行实质性的影响，所以我们将链表的地址传送给函数，并且将插入的数据也一同传输，方便尾插。

在尾插中，我们先使用ButSListNode函数来申请一个节点，这个节点中的值为x。然后我们需要进行判定：我们的链表当前是否为空，如果为空，那么我们的单链表直接将新节点插入即可

如果我们的节点不为空，那么我们需要进行找尾的操作，我们可以使用最后一个节点的指针指向NULL的点来使用循环找尾。于是我们使用一个while循环来进行查找

至此我们就完成了尾插的函数：

接下来，我们需要将单链表中的内容输出，才能知道我们至此完成的函数是否有问题，所以我们需要一个函数来输出链表。在这个函数中，我们不需要对链表的内容有改变，所以我们直接传输链表就可以

在链表的打印中，我们可以使用尾插中的找尾来进行内容的输出，在此，我们就可以完成链表打印的函数：

在上面三个函数的结合下，我们已经可以完成一个单链表，但是我们可以在这个基础上，再可以再添加一些功能，使得链表功能更完备。

我们可以再增删中寻找功能。我们已经有了尾插，所以我们可以再添加一个头插，尾删和头删。

我们可以先在尾插的基础上先写出一个尾删函数这个过程中，我们可以创建两个指针，一个用于找尾，一个用于存储链表最后节点的前一个节点，方便后续执行删除。

在这个过程中，可能存在仅有一个节点的情况，所以我们要特殊处理，只有一个节点的时候我们直接删除，由此我们完成了尾删函数

头插函数其实就是我们在求前面的节点添加一个，所以我们创建一个新节点然后链接上初始节点，然后将初始节点设置为新的节点就ok啦

头删就是我们将起始节点的下一个节点设置为初始节点，然后将原初始节点去除即可

以上的函数已经满足了我们增删的要求了，我们还需要插入和查找功能，所以我们接下来写一个查找函数。这个查找函数需要我们遍历链表，当出现对应值时，我们便返回该节点。

插入的函数我们可以分成在我们选择的节点前插入或之后插入。

在插入前，我们需要进行断言，必须确定我们选择的节点在当前链表内，所以我们对选择的节点进行严格的断言限定。

如果是在我们所选择的节点之后插入，我们直接将内容插入即可

如果是我们选择的节点之前插入，我们需要将单链表传输，因为我们需要找到前置节点

删除函数，我们直接将要删除节点的前后节点连接，然后将要删除节点删除即可

最后，我们还需要一个函数将内存释放，防止内存滥用。

在以上函数的加持下，我们就可以得到一个内容较为完备的动态单链表啦！代码内容如下，有可以改进的欢迎各位大佬提点！

//SList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);

// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x);
// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos);
void SLTDestroy(SListNode** pphead);

//SList.c
#define _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
// 单链表打印
void SListPrint(SListNode* plist)
{
	//assert(plist);空链表可以打印
	SListNode* tail = plist;
	while (tail != NULL)
	{
		printf("%d->", tail->data);
		tail = tail->next;
	}
	printf("NULL\n");
}


// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		SListNode* tail = *pplist;
		//找尾
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

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

// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	SListNode* tail = (*pplist)->next;
	free(*pplist);
	*pplist = tail;
}

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

// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* tail = pos->next;
	pos->next = pos->next->next;
	free(tail);
	tail = NULL;
}

// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{
	//严格限定pos一定是链表里面的一个有效节点
	assert(pphead);
	assert(pos);
	assert(*pphead);

	//assert((!pos && !(*pphead)) || (pos && *pphead));//要么都是空，要么都不是空
	
	if (*pphead == pos)
	{
		//头插
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos)
{
	assert(pos);
	assert(pphead);
	assert(*pphead);

	if (*pphead == pos)
	{
		//头删
		SListPopFront(pphead);
	}
	else
	{
		SListNode* tail = *pphead;
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		tail->next = pos->next;
		free(pos);
		pos = NULL;
	}
	
}

void SLTDestroy(SListNode** pphead)
{
	assert(pphead);
	SListNode* tail = *pphead;
	
	while (tail != NULL)
	{
		SListNode* prev = tail->next;
		free(tail);
		tail = prev;
	}
	*pphead = NULL;
}

//test.c
#define _CRT_SECURE_NO_WARNINGS
#include"SList.h"

void Test1()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SListPushFront(&plist, 5);
	SListPopBack(&plist);
	SListPopFront(&plist);
	SListPrint(plist);
	SListNode* pos = SListFind(plist, 2);
	SListPrint(pos);
}

void Test2()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SListNode* pos = SListFind(plist, 2);
	SListInsertAfter(pos, 5);
	SListPrint(plist);
	SListEraseAfter(pos);
	SListPrint(plist);
	SLTInsert(&plist, pos, 6);
	SListPrint(plist);
	SLTErase(&plist, pos);
	SListPrint(plist);
	SLTDestroy(&plist);
}
int main()
{
	Test2();
	return 0;
}