1.首先认识什么是单链表，知道其基本的定义：

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

结构图如下：

2.了解其来源（背景）

1.在顺序表中，对于整体空间的大小，在一定条件下会出现需要扩容的情况，而之前的顺序表在进行次操作时会出现一定的代价；
2.在对表中的元素进行相应的插入和删除操作时，顺序表往往存在一定的效率缺陷。

3.单链表的实现及其相应的操作，主要包括以下的函数，

// 动态申请一个节点
SLTNode* BuySLTNode(SLTDataType x);
//插入多个同时
SLTNode* CreateSList(int n);
// 单链表打印
void SLTPrint(SLTNode* phead);
// 单链表尾插
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);
// 单链表的销毁
void SListDestroy(SList* plist);
//在pos之前插入
void SListInsert(SListNode* pphead, SListNode* pos, SLTDateType x)；
//删除pos位置
void SListEraseAfter((SListNode** pphead ,SListNode* pos)；

4.具体操作如下：
（1） 动态申请一个节点，次操作相当于对其初始化的操作，我们可以动态对其进行初始化，这样的好处相比静态初始化后期的操作可能会更方便

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

（2）插入多个同时

SLTNode* CreateSList(int n)
{
	SLTNode* phead = NULL, *ptail = NULL;
	for (int i - 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		if (phead == NULL)
		{
			ptail = phead = newhead;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

（3） 单链表打印

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

（4）单链表尾插，在对表链表进行尾删的操作时，只需要两个节点，这里最难的是找尾，我们定义tail->next为尾，同时还要注意链表为空和顺序表为空的区别，同时使用二级指针来进行传递形参指向的内容

// 单链表尾插
void SListPushBack(SListNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuySLTNode(x);
	//判链表开始是否为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		// 找尾
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

注意：

1.改变int，传递int*给形参，形参进行交换改变
2.改变int，传递int**给形参，*形参进行交换改变

（5）单链表的头插，创建新节点newnode 指向第一个，对于第一个元素，又可以用地址来找到，这里为空时不需要单独处理

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

（6）

单链表的尾删，这里有两种写法：
1.第一种我们可以在tail在往下继续指向时定义一个prev，双指针，tail再走之前给到prev，在依次执行，最后在找到tail时，tail的前一个也可以找得到（这里不写出来，大家可以试试！）
2.可以直接通过tail->->next来判断，但需要考虑其中tail->为空的情况

void SListPopBack(SListNode** pphead)
{
	// 暴力的检查
	assert(*pphead);
	// 温柔的检查
	//if (*pphead == NULL)
	//	return;
	//判断开始时链表是否只有一个元素
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

（7）单链表头删，删除时需要断言一下，不能直接删，不然的话找不到下一个的地址，我们可以保存下一个，之后指向下一个就解决了，这就是单链表的优势所在

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

（8）单链表查找

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

（9）单链表在pos位置之后插入x，给出的位置不再是下标，而是指针，注意地址的衔接情况，这里可以不用二级指针，这里改变的是结构体，只需要结构体指针就可以了

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

（10）单链表删除pos位置之后的值

void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	//SListNode* next = pos->next;
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SListNode* nextNode = pos->next;
		pos->next = nextNode ->next;
		free(nextNode );
	}
}

（11） 单链表的销毁

// 单链表的销毁
void SListDestroy(SList* pphead)
{
	SListNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

（12）在pos之前插入

//在pos之前插入
void SListInsert(SListNode* pphead, SListNode* pos, SLTDateType x)
{
	assert(pos);
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SListNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

（13）删除pos位置

//删除pos位置
void SListEraseAfter((SListNode** pphead ,SListNode* pos)
{
	assert(pos);
	if (pos == *pphead)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

5.代码块如下：
test.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

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

6.总结

数据结构与算法比较复杂，需要多画图。链表题多判断边界，勤加练习。