单链表的实现

单链表的链表的概念及结构

概念

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

结构

• 在链表中，我们将带有需要存储的变量data与该结构体指针变量next的结构体设为一个结点，再将多个结点通过该结构体的成员next进行链接，就如上图所形成的数据结构，其中1为头节点，4为节点。
• 链表的结构在逻辑上是连续的，但在物理内存上不一定连续；
• 现实中的节点一般都是从堆区申请得来的；
• 从堆区申请的空间，按照一定的策略来分配，两次申请的空间可能连续，也可能不连续。

链表结构的分类

下面以32位环境下，结点存储信息位int类型为例来介绍链表的不同结构：

1. 带头链表与不带头链表
   

这里的带有链表的头结点仅为向导作用，他的next指向真正的头结点，存储的值可以是任意的。

2. 单向链表与双向链表
   

双向链表与单向链表不同的是他的结构体多了一个指向上一个结点的成员prev，这样的链表在进行特定点插入的时候，就会变得很方便了。

3. 循环链表与不循环链表
   

循环链表顾名思义，就是将未结点的next指向我们的头节点，从而使链表进行闭环。

以上就是链表的三种基本结构，但是我们可以根据这三种基本结构推出其他的复合状态的结构。

链表常用的结构

在日常生活中，我们常有的链表有下面两种：

1. 无头单向不循环链表
   
   常用的原因：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结构的⼦结构，如哈希桶、图的邻接表等等，另外这种结构在笔试⾯试中出现很多，这种链表就是我们本次要讲的链表。

2. 带头双向循环链表
   
   常用的原因：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，而实现它反而较为简单。

以上，就是两种常用的链表，下面让我们来看看本篇主要讲的无头单向不循环链表。

无头单向不循环链表

头文件 SList.h

#pragma once

#include
#include
#include


typedef int SLDataType;

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

SLNode* SLBuyNode(SLDataType x);//创建结点 

void SLInit(SLNode** pphead);//初始化链表
void SLPrint(SLNode* phead);//打印

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

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

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

void SLInsert(SLNode** pphead,SLNode* pos ,SLDataType x);//在该地址之前添加
void SLInsertAfter( SLNode* pos, SLDataType x);//在该地址之后添加

void SLErase(SLNode** pphead, SLNode* pos);//删除该单元
void SLEraseAfter(SLNode* pos);//删除该单元的下一单元

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

结构体 struct SListNode

typedef int SLDataType;

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

本篇文章使用int来演示链表结构体所存储的数据，所以利用#define将SLDataType重命名。
再定义一种结构体，结构体中放置SLDataType与自身结构体指针struct SListNode*两种成员变量。

源文件 SList.c

创建结点 SLNode* SLBuyNode(SLDataType x)

SLNode* SLBuyNode(SLDataType x)
{
	SLNode* node = (SLNode*)malloc(sizeof(SLNode));
	assert(node);
	node->data = x;
	node->next = NULL;
	return node;
}

#include
void* malloc (size_t size);//malloc()  分配大小为字节的内存块，返回指向块开头的指针。

利用malloc函数进行空间的申请，申请一个结点的空间，为防止申请失败返回空指针我们这里再用assert函数进行断言。若成功申请到空间，则分别对该结构体内的成员变量进行赋值即可，这里我们暂且不知道next的值，所以将next置空，最后再返回这个结点的指针即可。

初始化链表 void SLInit(SLNode** pphead)

void SLInit(SLNode** pphead)
{
	*pphead = NULL;
}

初始化链表顾名思义就是将链表置为空NULL ，这也是为了避免使用者在定义结构体指针的时候，没有初始化造成使用野指针的情况。

链表尾部插入 void SLPushBack(SLNode** pphead,SLDataType x)

void SLPushBack(SLNode** pphead,SLDataType x)
{
	assert(pphead);
	
	SLNode* node = SLBuyNode(x);
	if (!*pphead)
	{
		*pphead = node;
		return;
	}

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

SLPushBack函数接受二级指针也就是链表首结点的地址，这里我们必须要断言一下，检查指针是否正确传参。
再接着我们利用if语句判断链表的首结点是否为空NULL，若为空我们就进行特殊处理，将SLBuyNode函数返回的结点设为首结点；否则就初始化一个新变量pcur指向头结点，利用while循环使pcur走到未结点，然后将未结点的next指向SLBuyNode函数返回的新节点即可。

链表头部插入 void SLPushFront(SLNode** pphead, SLDataType x)

void SLPushFront(SLNode** pphead, SLDataType x)
{
	assert(pphead);
	SLNode* node = SLBuyNode(x);

	if (!*pphead)
	{
		*pphead = node;
		return ;
	}
	SLNode* pcur = *pphead;

	node->next = pcur;
	*pphead = node;
}

这里依旧是先对pphead进行断言，再开始向下执行语句。
利用if语句判断链表头结点是否为空，头结点为空就将 SLBuyNode函数返回的结点赋值给*pphead。
若不为空，就新命名一个指向*pphead的变量pcur，再将node->next指向刚刚新命名头结点pcur，最后将指向头结点的指针指向新的头结点node即可，流程如下图所示：

打印链表 void SLPrint(SLNode* phead)

void SLPrint(SLNode* phead)
{
	SLNode* pcur = phead;
	while (pcur!=NULL)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

这里只是对链表进行范围而非增添新的结点，所以在这里传的是一级指针。
我们先新命名一个指向头结点的指针pcur，再利用while循环遍历链表同时对链表中的元素进行打印即可，因为最后的结点的next指向空NULL或者该链表本身就为空，所以我们在最后打印一个NULL。

链表尾部删除 void SLPopBack(SLNode** pphead)

void SLPopBack(SLNode** pphead)
{
	assert(pphead && *pphead);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return ;
	}

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

对链表进行删除，首先我们要判断该链表的地址是否正确和该链表是否为空。
通过断言之后，利用if语句判断该链表是否只有一个结点，若只有一个结点我们就需要进行特殊处理，将唯一的结点释放掉在置为空即可，因为在单链表在删除过程中需要知道要删除结点的前一个结点。若为正常处理，我们就需新命名一个指针变量pcur，再用while循环找到next指向删除结点的上一个结点pcur，利用上一个结点pcur的next指向删除结点的next，这样就可以让删除结点从链表中脱离出来，再用free对其进行释放即可，就如下图所示：

链表头部删除 void SLPopFront(SLNode** pphead)

void SLPopFront(SLNode** pphead)
{
	assert(pphead && *pphead);
	SLNode* del = *pphead;

	*pphead = (*pphead)->next;
	free(del);
	del = NULL;
}

老规矩先断言。
通过断言后，新命名一个指向头结点的指针del，再让头结点等于其自身的next，再然后将del释放掉即可。

销毁单链表 void SLDesTroy(SLNode** pphead)

void SLDesTroy(SLNode** pphead)
{
	assert(pphead);
	SLNode* pret = *pphead;

	while (*pphead)
	{
		pret = (*pphead)->next;
		free(*pphead);
		*pphead = pret;
	}
}

先断言，再新命名一个指向头结点的指针变量pret让头结点依次随着next走动，在*pphead走向next之后，利用pret释放掉`*pphead的上一个结点,如此循环直到*pphead为空时，循环结束。

测试插入数据与删除数据 test.c

#include"SList.h"
int main()
{
	SLNode* phead;
	SLInit(&phead);

	SLPushBack(&phead, 2);
	SLPushBack(&phead, 3);
	SLPrint(phead);//2->3->NULL

	SLPushFront(&phead, 1);
	SLPushFront(&phead, 0);
	SLPrint(phead);//0->1->2->3->NULL

	SLPopBack(&phead);
	SLPrint(phead);//0->1->2->NULL

	SLPopFront(&phead);
	SLPrint(phead);//1->2->NULL

	return 0 ;
}

测试环节：

1. 先依次尾插2和3，打印结果理应为2->3->NULL；
2. 依次头插1和0，打印结果理应为0->1->2->3->NULL；
3. 对链表进行未删，打印结果理应为0->1->2->NULL；
4. 对链表进行头删，打印结果理应为1->2->NULL；

以上测试运行结果如下图所示：

查找链表元素 SLNode* SLFind(SLNode** pphead, SLDataType x)

SLNode* SLFind(SLNode** pphead, SLDataType x)
{
	assert(pphead && *pphead);
	SLNode* pcur = *pphead;

	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}

	return NULL;
}

先断言保证程序可正常运行。
新命名一个指向头结点的指针pcur，利用while循环遍历链表，当满足pcur->data == x时返回该结点pcur；如果pcur跳出while循环，说明链表中没有要查找的元素，就返回NULL。

在指定位置之前添加数据 void SLInsert(SLNode** pphead,SLNode* pos ,SLDataType x)

void SLInsert(SLNode** pphead,SLNode* pos ,SLDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLNode* node = SLBuyNode(x);
	if (pos == *pphead)
	{
		node->next = *pphead;
		*pphead = node;
		return;
	}

	SLNode* pret = *pphead;
	while (pret->next != pos)
	{
		pret = pret->next;
	}

	node->next = pos;
	pret->next = node;
}

先断言保证程序可正常运行。
利用SLBuyNode函数得到一个储存元素为x的结点，再利用if语句判断特例pos == *pphead，若为真就进行头插即可；若不为真，就新命名一个指向头结点的指针pret，依旧是遍历链表找到pret->next == pos的位置，再在pret后面插入数据即可。这里的插入，先将node->next指向pos，再将pret>next指向node即可，如下图所示：

在指定位置之后添加数据 void SLInsertAfter(SLNode** pphead,SLNode* pos ,SLDataType x)

void SLInsertAfter( SLNode* pos, SLDataType x)
{
	assert(pos);

	SLNode* node = SLBuyNode(x);
	
	node->next = pos->next;
	pos->next = node;
}

先断言保证程序可正常运行，再正常向后插入即可。

测试指定位置插入数据

#include"SList.h"

int main()
{
	SLNode* phead;
	SLInit(&phead);

	SLPushBack(&phead, 1);
	SLPushBack(&phead, 2);
	SLPushBack(&phead, 3);
	SLPrint(phead);//1->2->3->NULL

	SLInsert(&phead, SLFind(&phead, 1), 0);
	SLPrint(phead);//0->1->2->3->NULL
	SLInsert(&phead, SLFind(&phead, 3), 4);
	SLPrint(phead);//0->1->2->4->3->NULL

	SLInsertAfter(&phead, SLFind(&phead, 1), 9);
	SLPrint(phead);//0->1->9->2->4->3->NULL
	SLInsertAfter(&phead, SLFind(&phead, 3), 5);
	SLPrint(phead);//0->1->9->2->4->3->5->NULL

	return 0 ;
}

测试环节：

1. 先依次尾插1，2和3，打印结果理应为1->2->3->NULL；
2. 向结点为1的位置之前插入0，打印结果理应为0->1->2->3->NULL；
3. 向结点为3的位置之前插入4，打印结果理应为0->1->2->4->3->NULL；
4. 向结点为1的位置之后插入9，打印结果理应为0->1->9->2->4->3->NULL；
5. 向结点为3的位置之后插入5，打印结果理应为0->1->9->2->4->3->5->NULL；

以上测试运行结果如下图所示：

删除指定结点 void SLErase(SLNode** pphead, SLNode* pos)

void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	SLNode* pret = *pphead;
	if (pret == pos)
	{
		SLPopFront(pphead);
		return;
	}
	while (pret->next!=pos)
	{
		pret = pret->next;
	}
	pret->next = pos->next;
	free(pos);
	pos = NULL;
}

先断言保证程序可正常运行，再判断特例。
若不为特例，就while循环遍历，找到pos上一个结点，再进行删除即可。

删除指定结点的下一结点 void SLEraseAfter(SLNode* pos)

void SLEraseAfter(SLNode** pphead,SLNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	if (!pos->next)
	{
		return;
	}
	SLNode* pcur = *pphead;
	while (pos != pcur)
	{
		cur = cur->next;
	}
	SLNode* del = pcur->next;
	pcur->next = del->next;
	free(del);
	del = NULL;
}

先断言保证程序可正常运行，如果pos->next为空就说明要删除的为空，我们直接返回即可。
若pos->next不为空，就新命名一个指向头结点的指针变量pcur，遍历链表当pos==pcur的时候跳出while循环，再命名一个指针指向pcur->next，再将pcur->next 指向del->next，最后释放掉del即可。

测试指定位置删除数据

#include"SList.h"

int main()
{
	SLNode* phead;
	SLInit(&phead);

	SLPushBack(&phead, 1);
	SLPushBack(&phead, 2);
	SLPushBack(&phead, 3);
	SLPushBack(&phead, 4);
	SLPushBack(&phead, 5);
	SLPushBack(&phead, 6);
	SLPrint(phead);//1->2->3->4->5->6->NULL

	SLErase(&phead, SLFind(&phead, 1));
	SLPrint(phead);//2->3->4->5->6->NULL
	SLErase(&phead, SLFind(&phead, 6));
	SLPrint(phead);//2->3->4->5->NULL

	SLEraseAfter(&phead,SLFind(&phead, 5));
	SLPrint(phead);//2->3->4->5->NULL
	SLEraseAfter(&phead,SLFind(&phead, 2));
	SLPrint(phead);//3->4->5->NULL

	return 0 ;
}

测试环节：

1. 先依次尾插1，2，3，4，5，6，打印结果理应为1->2->3->4->5->6->NULL；
2. 指定删除1，打印结果理应为2->3->4->5->6->NULL；
3. 指定删除6，打印结果理应为2->3->4->5->NULL；
4. 指定删除5之后的结点，打印结果理应为2->3->4->5->NULL；
5. 指定删除2之后的结点，打印结果理应为2->4->5->NULL

以上测试运行结果如下图所示：

结语

本期的内容到这里就结束了，谢谢各位的支持！
下期小编将为大家带来基于本期的单链表所实现的贪吃蛇小游戏。
那么，喜欢请多多关照吧！！！