数据结构——单链表

绪论：

通过代码实现单链表的尾插、头插、尾删、头删、数据查找并返回地址、指定数据前插入、指定数据后插入、删除指定位置数据、删除指定位置后的数据、销毁链表等自定义函数。针对在单链表实现过程中所出现的问题进行讨论。同时对于初学者的我而言，始终将下标铭记于心：

一、头文件

头文件当包含以下信息：

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

typedef int SLTDataType;//与顺序表一致，方便后续修改数据类型

typedef struct SLTList       //单链表中，每个节点存储的内容为：
{
	SLTDataType data;        //1、数据 
	struct SLTList* next;    //2、下一个节点的起始地址，通过该地址，能够找到下一个节点处
}SLTNode;//typedef 结构体，便于后续编码


//尾插和头插函数
void SLTPushBack(SLTNode** pphead , SLTDataType x);
void SLTPushFront(SLTNode** pphead , SLTDataType x);

//尾删和头删函数
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//查找指定数据，并返回地址
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//指定位置前插入和指定位置后插入
void SLTInvert(SLTNode** pphead, SLTNode* find,SLTDataType x);
void SLTInvertBack(SLTNode* find,SLTDataType x);

//删除指定位置的数据和删除指定位置后的数据
void SLTErase(SLTNode** pphead, SLTNode* find);
void SLTEraseBack( SLTNode* find);

//销毁链表
void SLTDestroy(SLTNode** pphead);

//打印链表
void print(SLTNode* phead);

二、单链表的具体实现方式

1：尾插

测试函数如下：

void SLTListTest()
{
	SLTNode* plist = NULL;

    SLTPushBack(&plist,1);
    SLTPushBack(&plist,2);
    SLTPushBack(&plist,3);
    SLTPushBack(&plist,4);
    SLTPushBack(&plist,5);
    print(plist);
	SLTDestroy(&plist);
}

问：传值调用，还是传址调用？

我们通过阅读代码得知，代码中定义了一个结构体指针变量 plist，且该指针变量的初始值为 NULL，我们要通过调用函数，将该结构体内的成员改变。因此，此处应当为传址调用。

注：对于新手（我）来说有一个误区，即：不要觉得实参是指针变量，就是传址调用！传址即传该变量的地址！指针也是有他自己的地址的，要想让指针中存放的内容发生改变，就得将该指针的地址作为实参传递，在自定义函数中，用二级指针来接收。

再捋一下思路：结构体指针 plist 一开始指向 NULL。我们需要开辟一个新的节点，让 plist 指向这块空间，这样必定会改变 plist 内存储的值（该值为动态内存函数所开辟空间的起始值），因此需要传址调用。

如果是传值调用，只是把一个空指针传给了形参，且系统会给该形参重新开辟一块空间，后续的操作都在该空间内进行，因此不会影响到原空间，plist始终未为NULL。

但如果是传址调用的话，我们将该指针的地址作为实参传递给形参，形参用一个二级指针来接收，那么通过解引用该二级指针，便可以实现对实参进行修改。

①：尾插的一个大致思路：

情形1：无节点

不存在任何一个节点，我们要将 plist 指向 newcode（节点地址）

情形2：有节点

已有节点，我们需要遍历各个节点，直到该节点存储的地址为NULL，假设我们将起始地址的节点赋值给 结构体指针 p，当 p->next == NULL时，将新节点的地址赋值给 p->next

②：尾插的实现代码：

思路：

首先要先实现新节点的创建，通过前面阅读可以得知，

一个节点中包含两个成员：1、数据；2、指向下一个节点的指针，若没有赋值为NULL

我们通过动态内存函数，开辟动态内存空间，同时将数据传递给节点中的data成员，并将节点中的指针置为空，最后通过返回起始地址，来开辟一个新的节点，实现代码如下：

注：补充一些前面所学：返回值是什么类型变量，自定义函数名前就是什么类型

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	assert(node);
	node->data = x;
	node->next = NULL;

	return node;
}

我们可以想象一下，通过上述代码，现在系统内存中有这样一个节点闲置在那：

Ⅰ：有自己的地址（动态内存函数给的，为：node），且通过该地址可以访问所有成员；

Ⅱ：有自己数据data（用户给的x）；

Ⅲ：有能够指向下一个节点地址的指针（暂时为NULL）

实现：

接下来我们就得通过解引用形参来访问实参接收这个新地址

尾插代码如下：

void SLTPushBack(SLTNode** pphead , SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);//开辟一个新节点，该节点中

	if (*pphead == NULL)    //情形1，解引用后发现plist为空，说明当前不存在任何节点
	{
		*pphead = newnode;  //*pphead 即为plist，将节点地址赋给plist，plist就能访问所有成员
	}
	else                    //情形2： 看注解：
	{
		SLTNode* pcur = *pphead;//我们需要定义一个临时结构体指针 pcur，去寻找尾部
		while (pcur->next != NULL)//当不满足条件时，此时pcur处于尾部
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;//跳出循环，此时pcur位于尾部，将新节点赋值给p->next，完成尾插
	}
}

注：针对情形2，还需补充1点：情形2中，单链表已有雏形，*pphead 即 plist 已经能够访问各个节点，倘若此时不定义临时变量 pcur，而通过 *pphead直接去查表，那会改变节点的起始位置，从而指向尾部位置，最终导致的时，无法通过 plist访问先前的节点，如图

2：头插

思路：

情形1与尾插类似，不多赘述；

情形2：要将plist指向新节点地址，其次还需要将新节点中的指针指向原来单链表的起始位置处。

实现：

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)      //情形1：一开始无节点
	{
		*pphead = newnode;
	}
	else                      //情形2：一开始有节点
	{
		SLTNode* tmp = *pphead;//创建临时结构体指针存放起始节点地址
		*pphead = newnode;
		(*pphead)->next = tmp;
	}
}

打印结果：

打印的代码如下：

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

这里为什么创建临时变量pcur不再赘述，此处需要结合下图讨论pcur这个循环条件

思路：pcur起始不为NULL——>进入循环——>打印当前节点数据——>将下一节点地址赋给pcur

pcur仍不会空——>进入循环——>以此往复，直至pcur打印完data4后——>将NULL传递给pcur

——>下一次循环条件不满足，结束循环，打印NULL。

尾插和头插的打印结果如图所示

3：尾删和头删

尾删的大致思路：

情形1：

只有一个节点，直接free，指针置为空即可

情形2：

存在多个节点，需要创建两个临时结构体变量来遍历各个节点，找到尾部节点和前一个节点，再free尾部节点，指针置为空，同时将前一个节点的存放指针的变量置为空

尾删实现：

代码如下

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);//要有节点可删，因此多了*pphead 非空这个条件

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* pcur = *pphead;
		SLTNode* pre = *pphead;
		while (pcur->next)
		{
			pre = pcur;
			pcur = pcur->next;
		}
		free(pcur);
		pre->next = NULL;
		pcur = NULL;
	}
}

头删实现：

头删的实现较为简单，只需创建临时变量，存放第一个节点中存储的地址，free后，将*pphead重新指向该地址。

代码如下：

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* tmp = (*pphead)->next;
	free(*pphead);
	*pphead = tmp;
}

4：查找数据

通过定义一个临时结构体变量遍历每个节点查找符合的节点，并返回该地址

代码如下：

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

5：指定位置前和指定位置后插入数据

指定位置前插入：

思路：

情形1：

若指定位置与单链表起始位置相同，则直接调用头插函数

情形2：

若在中间位置插入，例如data3前

通过查找函数，我们能够得知存放data3节点的地址，通过 pcur->next ！= 该地址 作为条件，以此循环找到前一个节点的地址，创建一个临时变量来保存pcur指向地址所存储的指针，同时再将新节点的地址赋给此指针，最后再将临时变量的值赋给新节点中的指针。

实现：

void SLTInvert(SLTNode** pphead, SLTNode* lo, SLTDataType x)
{
	assert(pphead);
	assert(lo);
	if (*pphead == lo)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* pcur = *pphead;
		while (pcur->next != lo)
		{
			pcur = pcur->next;
		}
		SLTNode* tmp = pcur->next;
		pcur->next = newnode;
		newnode->next = tmp;
	}
}

指定位置后插入：

将前者来说，更为简单，代码如下：

void SLTInvertBack(SLTNode* find, SLTDataType x)
{
	assert(find);
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* tmp = find->next;
	find->next = newnode;
	newnode->next = tmp;
}

6：删除指定位置节点和删除指定位置后的节点

删除指定位置节点：

思路：

情形1：

指定位置与单链表起始位置相同，直接调用头删函数

情形2：

假设删除data3，如下图：

通过查找函数可以得知存储data3节点的地址，通过条件 pcur->next ！= 该地址，以此循环找到该地址的前一个位置。

实现：

代码如下：

void SLTErase(SLTNode** pphead, SLTNode* find)
{
	assert(pphead && find);
	if (*pphead == find)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next != find)
		{
			pcur = pcur->next;
		}
	        pcur->next = find->next;
            free(find);
            find = NULL;
	}
}

删除指定位置后节点：

代码如下：

void SLTEraseBack(SLTNode* find)
{
	assert(find&&find->next); // 最后一个节点之后无节点可删
	SLTNode* tmp  = find->next->next;
	free(find->next);
	find->next = tmp;
}

6：销毁链表

代码如下：

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* tmp = pcur->next;
		free(pcur);
		pcur = tmp;
	}
	*pphead = NULL;
}