《单链表》的实现（不含哨兵位的单向链表）

编辑

前言：

链表的概念及结构：

链表的实现：

[2.打印链表：](#2.打印链表：)

[4.尾插：](#4.尾插：)

[6.尾删：](#6.尾删：)

[11. 指定下标后插入：](#11. 指定下标后插入：)

[12.删除当前下标的后一个节点：](#12.删除当前下标的后一个节点：)

13.销毁链表：

总结：

前言：

我们在前面的学习中深度的讲解了顺序表的模拟实现，而在上一篇好题分享中，我们又对于链表中的几道基础题（含有含金量）作出了完善的解析，今天我们将要真正的开启链表的学习，就从最基础的模拟实现一个单链表开始

前两篇的blog在这里：

好题分析（2023.10.29------2023.11.04）-CSDN博客

《动态顺序表》的实现-CSDN博客

链表的概念及结构：

链表（Linked List）是一种常见的数据结构，它是由一系列节点（Node）组成的，每个节点包含两个部分：数据域和指针域。数据域存储数据，指针域指向下一个节点。

链表可以分为单向链表和双向链表两种：

单向链表：每个节点只有一个指针域，指向下一个节点。

双向链表：每个节点有两个指针域，一个指向前一个节点，一个指向后一个节点。

链表相较于数组，具有以下优势：

内存空间可以动态分配，不需要预先定义大小。
插入和删除操作比较容易，只需要改变指针指向即可，不需要移动元素。
可以节省内存空间，因为链表中的节点可以零散分布在内存中，不需要连续的空间。

但是链表的缺点是：

访问元素的时间复杂度为O(n)，而数组可以通过下标随机访问元素，时间复杂度为O(1)。
链表的节点需要额外的指针域来存储指向下一个节点的指针，因此内存占用相对于数组较大。

这些特点使得链表在某些场景下比数组更加适用，比如实现队列、栈、哈希表等数据结构，或者需要频繁插入和删除元素的场景。

介绍完链表的基本信息，下面我们就来实现链表！

链表的实现：

1.typedef数据类型：

cpp 复制代码

typedef int SLNDataType;

typedef struct SlistNode
{
	SLNDataType val;
	struct SlistNode* next;
}SLNode;

这里与我们最早实现通讯录和顺序表的结构相似，在这里我就不过多赘述。

2.打印链表：

cpp 复制代码

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

打印函数的内容较好理解，在这里我不进行过多的赘述。

3.创建新节点：

cpp 复制代码

SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("CreateNode -> malloc");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	return newnode;
}

这里与我们在顺序表中，在堆区申请空间而使用的malloc相似。

在这里我们是定义了一个指针newnode，这里要注意的是此时的newnode的返回值是SLNode*，意思就是指向一个SLNode类型的结构体指针！

所以对于该结构体我们就给它赋予初始值，即newnode->val = x;newnode->next = NULL;

4.尾插：

cpp 复制代码

void SLTPushBack(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;

	}
}

对于此函数的实现，我们首先要讲解的就是此时的形参必须是一个二级指针！

我们都知道，

形参是实参的一份临时拷贝！

我们在实现这些关于结构体的函数，传递的都是结构体的地址。

对于顺序表和通讯录，我们这样传递不成问题。例：

cpp 复制代码

Contact c;

CreateContact(&c);

等等代码。因为我们一开始是创建了一个结构体C，这时我们想要在结构体里修改各个成员的值，就需要调用CreateContact函数，那么我们都知道要传入结构体指针，因为当我们传入指针，指针可以在原来的数据上进行修改，同时可以返回到修改完的数据。

但当我们仅仅传一个C，而非指针时，此时函数内部就会再创建一个结构体，对新创建的结构体里的各个成员进行修改，一旦函数结束，此结构体就会销毁，原来的结构体不会发生改变。

这就是为什么形参是实参的一份临时拷贝！

同理，

对于当前的链表，我们在主函数肯定会有：

cpp 复制代码

SLNode* plist = NULL;

我们在此刻是使用的结构体指针，而非结构体对象，因为我们使用结构体指针可以更方便访问链表的头结点，进而进行许许多多的操作。

那如果我们在函数里用的是一级指针的话，就会出现：

当我们实施添加节点时，

看似我们创建了新节点，但实际上是这样的。

一旦函数结束，phead就会销毁，新开辟出来的结点就会找不到。

就会导致内存泄漏。

所以正确的做法就是利用二级指针，来解引用得到原指针而修改里面的next，并且指向新节点。

即：

这就很好的解释了为什么要用双指针来接收。

然后就是要注意，当指针为NULL和指针已经指向节点要分开讨论。

5.头插：

cpp 复制代码

void SLTPushFront(SLNode** pphead, SLNDataType x)
{
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

头插的代码很好理解，在这里我不做过多赘述。

6.尾删：

cpp 复制代码

void SLTPopBack(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLNode* tail = *pphead;
	if (tail->next == NULL)
	{
		free(tail);
		tail = NULL;
	}
	else
	{
		SLNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = NULL;
		free(tail);
		tail = NULL;
	}
	
}

对于该函数的实现，注意的就是要保存最后一个节点前的结点，这样我们就可以将前一个节点的next指向NULL。

同时注意要将空节点和有节点分开讨论。

7.头删：

cpp 复制代码

void SLTPopFront(SLNode** pphead)
{
	assert(*pphead);
	assert(pphead);
	SLNode* tmp = (*pphead)->next;
	free(*pphead);
	*pphead = tmp;
}

头删的大致思路与尾删类似，在这里我不过多赘述。

8.查找节点：

cpp 复制代码

SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	assert(phead);
	while (phead)
	{
		if (phead->val == x)
		{
			return phead;
		}
		phead = phead->next;
	}
	return NULL;
}

9.指定下标前插入：

cpp 复制代码

void SLTInsertBefore(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	
	SLNode* tail = *pphead;
	if ((*pphead) == NULL)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		SLNode* newnode = CreateNode(x);
		newnode->next = pos;
		tail->next = newnode;
	}
}

10.删除当前下标

cpp 复制代码

void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	SLNode* tmp = *pphead;

	if (*pphead == pos)
	{
		SLTPopBack(pphead);
	}

	else
	{
		while (tmp->next != pos)
		{
			tmp = tmp->next;
		}

		tmp->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

11. 指定下标后插入：

cpp 复制代码

void SLTInsertAfter(SLNode* pos, SLNDataType x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

12.删除当前下标的后一个节点：

cpp 复制代码

void SLTEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLNode* tmp = pos->next;
	pos->next = tmp->next;
	free(tmp);
	tmp = NULL;
}

13.销毁链表：

cpp 复制代码

void SLTDestory(SLNode** pphead)
{
	assert(pphead);
	SLNode* prev = NULL;
	while (*pphead)
	{
		prev = *pphead;
		*pphead = (*pphead)->next;
		free(prev);
	}
	prev = NULL;
}

总结：

在这里我仅仅只是讲解了实现单链表的基本概念，而对于后续的一些函数实现，我并没有进行过多的讲解，因为这些函数的实现与之前的尾插和头插大差不差。

需要注意的就是释放和插入的next指向，以及先后顺序。

这些在之后做题中会多次提到，我们也会不断熟练。

总之，对于这部分链表问题，我们应当多多练习多多刷题，提升我们的熟练度才是首要目标！

记住

"坐而言不如起而行"

Action speake louder than words

以下是我本次文章的全部代码：

Data structures amd algorithms: 关于数据结构和算法的代码 - Gitee.com

《单链表》的实现（不含哨兵位的单向链表）

前言：

链表的概念及结构：

链表的实现：

1.typedef数据类型：

2.打印链表 ：

3.创建新节点：

4.尾插 ：

5.头插：

6.尾删 ：

7.头删：

8.查找节点：

9.指定下标前插入：

10.删除当前下标

11. 指定下标后插入：

12.删除当前下标的后一个节点 ：

13.销毁链表：

总结：

2.打印链表：

4.尾插：

6.尾删：

12.删除当前下标的后一个节点：