1. 顺序表的缺陷

为什么会有链表？

我们都有顺序表来存储数据了，

因为顺序表是有缺陷的：

1. 中间头部插入删除数据，需要挪动数据，效率低下。

2. 空间不够需要扩容，扩容会有一定的消耗，也可能会造成空间的浪费。

这时候，我们就要用到链表。

2. 单链表

链表是一种物理存储结构上非连续、非顺序的存储结构，

数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

如下图：

2.1 单链表的基本结构与接口函数

基本结构：

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;

typedef struct SListNode
{
	SLDataType data;
	struct SListNode* next;
}SLNode;

//打印链表
void SLPrint(SLNode* phead);

//尾插
void SLPushBack(SLNode** pphead, SLDataType x);

//头插
void SLPushFront(SLNode** pphead, SLDataType x);

//尾删
void SLPopBack(SLNode** ppheadx);

//头删
void SLPopFront(SLNode** pphead);

//查找
SLNode* SLFind(SLNode* phead, SLDataType x);

//插入
void SLInsert(SLNode** phead, SLNode* pos, SLDataType x);

//删除
void SLErase(SLNode** phead, SLNode* pos);

//从pos后面插入
void SLInsertAfter(SLNode* pos, SLDataType x);

//从pos后面删除
void SLEraseAfter(SLNode* pos);

2.2 重要接口

创建新节点的函数：

//建立一个新节点（重复操作写成函数复用）
SLNode* BuyNewNode(SLDataType x)
{
	//malloc一个链表节点大小的空间
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));

	//检查
	if (newnode == NULL)
	{
		perror("malloc::fail");
		return;
	}

	//赋值
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

2.2.1 尾插

//尾插
void SLPushBack(SLNode** pphead, SLDataType x)
{
	//检查二级指针pphead地址是否为空	
	//方便检查是否传空指针了
	assert(pphead);

	//创建节点
	SLNode* newnode = BuyNewNode(x);

	//如果链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else//如果链表不为空
	{
		//找尾
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		//尾插
		tail->next = newnode;
	}
}

2.2.2 头插

//头插
void SLPushFront(SLNode** pphead, SLDataType x)
{
	//检查二级指针pphead地址是否为空	
	//方便检查是否传空指针了
	assert(pphead);

	//创建节点
	SLNode* newnode = BuyNewNode(x);

	//头插
	newnode->next = *pphead;
	*pphead = newnode;
}

2.2.3 尾删

//尾删
void SLPopBack(SLNode** pphead)
{
	//检查二级指针pphead地址是否为空	
	//方便检查是否传空指针了
	assert(pphead);
	//检查链表是否为空
	assert(*pphead);
	
	//头删的情况（链表只有一个数据）
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找尾
		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		//尾删
		free(tail->next);
		tail->next = NULL;
	}
}

2.2.4 头删

//头删
void SLPopFront(SLNode** pphead)
{
	//检查二级指针pphead地址是否为空	
	//方便检查是否传空指针了
	assert(pphead);
	//检查链表是否为空
	assert(*pphead);

	//头删
	SLNode* cur = (*pphead)->next;
	free(*pphead);
	*pphead = NULL;
	*pphead = cur;
}

2.2.5 查找

//查找
SLNode* SLFind(SLNode* phead, SLDataType x)
{
	//创建指针遍历链表
	SLNode* cur = phead;

	//查找
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

2.2.6 插入

//插入
void SLInsert(SLNode** pphead, SLNode* pos, SLDataType x)
{
	//检查查找的地址是否为空
	assert(pos);

	//pos的位置
	if (pos == *pphead)
	{
		SLPushFront(pphead, x);
	}
	else//在链表中间
	{
		SLNode* prev = *pphead;

		//查找pos对应位置
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		//插入
		SLNode* newnode = BuyNewNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

2.2.7 删除

//删除
void SLErase(SLNode** pphead, SLNode* pos)
{
	//检查二级指针pphead地址是否为空	
	//方便检查是否传空指针了
	assert(pphead);

	//检查查找的地址是否为空
	assert(pos);

	//检查链表是否为空（这里其实不断言也可以）
	assert(*pphead);

	//头删的情况
	if (*pphead == pos)
	{
		SLPopFront(pphead);
	}
	else
	{
		//查找
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		//删除
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

2.2.8 从pos后面插入

//从pos后面插入
void SLInsertAfter(SLNode* pos, SLDataType x)
{
	//检查查找的地址是否为空
	assert(pos);

	//创建节点
	SLNode* newnode = BuyNewNode(x);

	//再pos后面插入
	newnode->next = pos->next;
	pos->next = newnode;
}

2.2.9 从pos后面删除

//从pos后面删除
void SLEraseAfter(SLNode* pos)
{
	//检查查找的地址和要删除的地址是否为空
	assert(pos);
	assert(pos->next);

	//在pos后面删除，prev记住要删除的节点，然后free
	SLNode* prev = pos->next;
	pos->next = prev->next;
	free(pos->next);
	prev = NULL;
}

这就是单链表的基本框架和接口了，

如果感兴趣，你也可以使用接口函数玩一玩。