单链表的实现

1、链表的概念和结构

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

链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独立存在的。

车厢是独立存在的，且每节车厢都有车门。想象⼀下这样的场景，假设每节⻋厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢里都放一把下一节车厢的钥匙。与顺序表不同的是，链表⾥的每节"⻋厢"都是独立申请下来的空间，我们称之为“结点/节点”节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下⼀个节点的位置？

链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），我们需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型：

struct SListNode
{
 int data; //节点数据
 struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};

当我们想要保存一个整型数据时，实际是向操作系统申请了一块内存，这个内存不仅要保存整型数据，也需要保存下一个节点的地址（当下一个节点为空时保存的地址为空）。
当我们想要从第一个节点走到最后一个节点时，只需要在前一个节点拿上下一个节点的地址（下一个节点的钥匙）就可以了。
补充说明：
1、链式机构在逻辑上是连续的，在物理结构上不一定连续
2、节点一般是从堆上申请的
3、从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续

2、单链表的实现

SList.h --文件

//单链表
typedef int SLNDataType;
typedef struct SListNode {
	SLNDataType data;
	struct SListNode* next;
}SLNode;

//循环打印
void SLPrint(SLNode* phead);

//尾插
void SLPushBack(SLNode** pphead, SLNDataType x);
//头插
void SLPushFront(SLNode** pphead, SLNDataType x);
//尾删
void SLPopBack(SLNode** pphead);
//头删
void SLPopFront(SLNode** pphead);
//指定的位置之前插入删除 
void SLInsert(SLNode** pphead, SLNode* pos, SLNDataType x);
//指定位置之后插入数据 
void SLInsertAfter(SLNode* pos, SLNDataType x);
 
//指定位置之前删除数据pos节点
void SLErase(SLNode** pphead, SLNode* pos);
//指定位置之后删除数据
void SLEraseAfter(SLNode* pos);

//查找节点
//这里传一级指针就可以，因为不改变头结点
//但是需要二级指针接收，因为需要代码一致性，接口一致性
SLNode* SLFind(SLNode** pphead, SLNDataType x);

// 链表的销毁
void SLDesTroy(SLNode** pphead);

SList.c --文件

void SLPrint(SLNode* phead) {
	//循环打印
	//可以用phead来直接来访问，但是注意，当代码走到
	//第14行的时候，此时pheadi已经变成NULL了
	//若代码没写完，我还要继续使用指向第一个节点的地址时，这时我就
	//找不到第一个节点的地址，则需要将任务交给pcur
	SLNode* pcur = phead;
	while (pcur) {
		printf("%d ->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//方便快速初始化一个新的节点
SLNode* SLByNode(SLNDataType x) {
	SLNode* node = (SLNode*)malloc(sizeof(SLNDataType));
	node->data = x;
	node->next = NULL;
	return node;
}

//尾插
void SLPushBack(SLNode** pphead, SLNDataType x) {
	assert(pphead);
	SLNode* node = SLByNode(x);
	if (*pphead == NULL) {
		*pphead = node;
		return;
	}
	SLNode* pcur = *pphead;
	while (pcur->next != NULL) {
		pcur = pcur->next;
	}
	pcur->next = node; 
}
//头插
void SLPushFront(SLNode** pphead, SLNDataType x) {
	assert(pphead);
	//申请空间
	SLNode* node = SLByNode(x);
	//让新节点和头节点连接起来
	node->next = *pphead;
	//让新的节点成为头节点
	*pphead = node;
}
//尾删(考虑当只有一个节点的时候）
void SLPopBack(SLNode** pphead) {
	assert(pphead);
	assert(*pphead);
	//当只有一个节点的情况
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}

	SLNode* pcur = *pphead;
	SLNode* prev = NULL;
	while (pcur->next != NULL) {
		prev = pcur;
		pcur = pcur->next;
	}  
	prev->next = NULL;
	free(pcur); 
	prev = NULL;

}
//头删(考虑当只有一个节点的时候）
void SLPopFront(SLNode** pphead) {
	assert(pphead);
	assert(*pphead);
	//这里只有一个节点的情况也可运行
	SLNode* temp = *pphead;
	*pphead = temp->next;
	free(temp);
	temp = NULL;
}

//任意位置之前插入 （注意）
void SLInsert(SLNode** pphead, SLNode* pos, SLNDataType x) {
	assert(pphead);
	SLNode* node = SLByNode(x);
	//存在没有节点的情况 约定链表不能为空，pos也不能为空
	assert(*pphead);
	assert(pos);
	//存在只有一个节点的情况
	if ((*pphead)->next == NULL || pos == *pphead ) {
		node->next = *pphead;
		*pphead = node; 
		return;
	}
	SLNode* prev = *pphead;
	//找到pos的前一个节点
	while (prev->next != pos) {
		prev = prev->next;
	}
	//对前后节点的nest进行引用
	prev->next = node;
	node->next = pos;
}

//指定位置之后插入数据（常用）
void SLInsertAfter(SLNode* pos, SLNDataType x) {
	assert(pos);
	SLNode* node = SLByNode(x);
	//节点的交换，注意先后顺序
	node->next = pos->next;
	pos->next = node;

}

//指定位置删除pos节点的数据
void SLErase(SLNode** pphead, SLNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos); 
	//处理特殊情况
	if (pos == *pphead) {
		*pphead = (*pphead)->next;;
		free(pos);
		return;
	}
	//正常逻辑上的删除pos节点，先找到上个节点
	SLNode* prev = *pphead;
	while (prev->next != pos) {
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}
//指定位置之后删除数据
void SLEraseAfter(SLNode* pos) {
	assert(pos && pos->next);

	SLNode* prev = pos->next;
	pos->next = prev->next;
	free(prev);
	prev = NULL; 
}


//查找一个为x的节点
SLNode* SLFind(SLNode** pphead,SLNDataType x) {
	SLNode* pcur = *pphead;
	while (pcur) {
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
		return NULL;
}

//链表的销毁
void SLDesTroy(SLNode** pphead) {
	assert(pphead);
	SLNode* pcur = *pphead;
	while (pcur) {
		SLNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

test.c --文件

void lsttest01() {
	SLNode* plist = NULL;
	//尾插  这里涉及二级指针，传的是形参
	SLPushBack(&plist, 4);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 6);
	SLPushBack(&plist, 9);
	//头插
	SLPushFront(&plist, 1);
	//SLPopBack(&plist);
	//SLPopBack(&plist);
	SLPrint(plist);
	//SLPopFront(&plist);
	SLPrint(plist);

	//指定位置之前插入
	SLNode* find = SLFind(&plist, 9);
	SLInsert(&plist, find, 11);
	//指定位置之后插入
	SLNode* find = SLFind(&plist, 9);
	SLInsertAfter(find, 111);
	SLPrint(plist); 

	//指定位置之前删除数据
	SLErase(&plist, find);
	SLPrint(plist);
	//指定位置之后删除数据
	SLEraseAfter(find);
	SLPrint(plist);

	//销毁链表
	SLDesTroy(&plist);
	SLPrint(plist);
}

3、链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

链表说明：

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表 和 双向带头循环链表

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
   构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
   是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
   来很多优势，实现反而简单了，后面我们代码实现了就知道了。