揭开线性表的神秘面纱 —— 单链表

1. 链表的概念与结构

1.1 链表的概念

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

例如： 

由于链表的物理地址不连续的特殊性，我们在堆上malloc出节点用来存放链表数据，以单向链表为例，malloc出的节点包含数据域与指针域。

如下图所示的箭头指向是我们想象出来的，由于malloc申请空间是随机申请，所以节点的地址也是杂乱无章的，但在逻辑上我们想象他们是一条链子。 

1.2 链表的分类

实际中链表结构多种多样，链表有以下几种分类方式：

1.2.1 单向或者双向

1.2.2 是否带头节点

1.2.3 是否循环

1.3 常用结构 

 根据以上几种方式可以排列组合成八种链表结构，但我们常用的还是以下两种

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

本文模拟实现无头单向非循环链表，来加深对于单链表的印象。

2. 无头单向非循环链表的实现

2.1 思路详解

我们拟实现以下功能接口函数。

<1>   动态申请一个新的节点

<2>   单链表的头插

<3>   单链表的尾插

<4>   单链表的头删

<5>   单链表的尾删

<6>   单链表的查找

<7>   单链表的打印

<8>   单链表在pos位置后插入元素

<9>   单链表删除pos位置后的值

<10> 在pos的前面插入

<11>  删除pos位置

<12> 单链表的销毁

由于单向链表单向的特性，在实现函数过程中，我们只能从前往后，做不到从后往前，因此在许多功能中，我们都需要找到需要操作节点的前一个节点。

我们在单链表的实现中，需要完成单链表的创建，在各个位置的增删查改，以及最后的销毁链表。也就是上述的十几个函数接口。

本次实现我们依旧采用分文件编写，.h文件包含库函数文件，函数声明与结构体定义。.c文件用来实现各类函数的定义。

2.2 SList.h

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

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* CreateSListNode(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
void SListInsertAfter(SListNode* pos, SLTDateType x);

// 单链表删除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);

 2.3 SList.c

#include"SList.h"
//创建节点
SListNode* CreateSListNode(SLTDateType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	assert(newNode);//创建失败弹出错误窗口
	newNode->data = x;
	newNode->next = NULL;//初始化新节点
	return newNode;
}

//打印链表
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL");
	printf("\n");
}

//尾插节点
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* NewNode = CreateSListNode(x);
	//由于链表为空时，不能进行解引用，无法寻找(*pplist)->next,需要考虑链表为空的情况
	if (*pplist == NULL)//考虑链表为空时，则直接插入
	{
		*pplist = NewNode;
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next)//寻找链表末尾
		{

			cur = cur->next;
		}
		cur->next = NewNode;//将新节点插入到尾节点后
	}
}

//头插节点
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);//无需考虑链表为空，处理方式相同
	SListNode* NewNode = CreateSListNode(x);
	NewNode->next = *pplist;//新节点指向头指针指向的原头节点
	(*pplist) = NewNode;//头指针指向新的头节点
}

//尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);//不允许删除空表
	if ((*pplist)->next == NULL)//链表只有一个节点
	{
		free(*pplist);
		*pplist = NULL;
	}
	else//链表有多个节点
	{
		SListNode* cur = *pplist;
		while (cur->next->next)//寻找尾节点的前一个结点
		{
			cur = cur->next;
		}
		SListNode* tmp = cur->next;
		free(tmp);
		cur->next = NULL;
	}
}

//头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);//不允许传入空表
	SListNode* tmp = *pplist;//不用区分多节点或一个节点
	*pplist = (*pplist)->next;
	free(tmp);
}

//单链表的查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);
	assert(x);//不允许链表为空和查找数值为NULL
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

//在pos之后插入
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = CreateSListNode(x);
	newnode->next = pos->next;//在pos与pos->next之间插入新的节点
	pos->next = newnode;
}

//删除pos之后的节点
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	SListNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);
	SListNode* cur = *pphead;
	SListNode* newnode = CreateSListNode(x);
	if (*pphead == pos)
	{
		SListPushFront(pphead,x);
	}
	//while (cur)             错误示范
	//{
	//	if (cur->next == pos)
	//	{
	//		cur->next = newnode;
	//		newnode->next = pos;
	//		SListPrint(*pphead);      此处有带环节点
	//	}
	//	else
	//	{
	//		cur = cur->next;
	//	}
	//}
	while (cur->next != pos)//找到pos的前一个节点
	{
		cur = cur->next;
	}
	cur->next = newnode;
    newnode->next = pos;
}

//删除pos节点的位置
void SLTErase(SListNode** pphead, SListNode* pos)
{
	//找到pos前的位置cur，即(cur->next==pos)，但当pos等于头节点时，该条件不成立，
	//需要分开判断
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* cur = *pphead;
		while (cur->next != pos)//找到pos的前一个节点，将前一个节点与pos的后一个节点链接。
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//销毁链表，从第一个节点开始释放，直至NULL
void SLTDestroy(SListNode** pphead)
{
	assert(pphead);
	SListNode* cur = *pphead;
	while (*pphead)
	{
		*pphead = cur->next;
		free(cur);
		cur = *pphead;
	}
}

 各个函数实现的要点都注释在代码中了。

2.4 代码实现效果

测试代码就不呈现在这里了，直接给各位看效果。

本文单链表的实现告一段落，双链表的实现随后奉上，期待各位的观看与指正。