用C语言实现单链表

晨星0527

已于 2024-08-09 12:26:52 修改

阅读量571

点赞数 9

分类专栏：数据结构 C语言文章标签： c语言开发语言数据结构链表

于 2024-08-09 12:26:37 首次发布

本文链接：https://blog.csdn.net/qq_51904510/article/details/140860521

版权

C语言同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

数据结构

4 篇文章 0 订阅

订阅专栏

一. 链表的概念及结构

二. 单链表的实现

1. 在SList.h中结构体的定义和各函数的声明

2.7 在指定位置之前插入数据 SLTInsert

2.8 在指定位置之后插入数据 SLTInsertAfter

2.9 删除节点 SLTErase

2.10 删除pos之后的节点 SLTEraseAfter

2.11 链表的销毁 SListDestroy

一. 链表的概念及结构

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

火车车厢

链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独立存在的。

车厢是独立存在的，且每节车厢都有车门。想象一下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下如何从车头走到车尾？

最简单的做法：每节车厢里都放一把下一节车厢的钥匙。

在链表里，每节“车厢”是什么样的呢？

链表节点示意图

与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”

节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址（指针变量）。

图中指针变量 plist保存的是第一个节点的地址，我们称plist此时“指向”第一个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下一个节点的位置？

链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），我们需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：

假设当前保存的节点为整型：

typedef struct SListNode 
{
	int data;//数据
	struct SListNode* next;//指向下一个链表的地址
}SLTNode;

当我们想要保存一个整型数据时，实际是向操作系统申请了一块内存，这个内存不仅要保存整型数据，也需要保存下一个节点的地址（当下一个节点为空时保存的地址为空）。

当我们想要从第一个节点走到最后一个节点时，只需要在前一个节点拿上下一个节点的地址（下一个节点的钥匙）就可以了。

给定的链表结构中，如何实现节点从头到尾的打印？

思考：当我们想保存的数据类型为字符型、浮点型或者其他自定义的类型时，该如何修改？

补充说明：

1、链式机构在逻辑上是连续的，在物理结构上不一定连续

2、节点一般是从堆上申请的

3、从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续

二. 单链表的实现

1. 在SList.h中结构体的定义和各函数的声明

1.1 结构体（节点）的定义

typedef int SLTDataType;

//定义节点的结构
//数据 + 指向下一个节点的指针
typedef struct SListNode 
{
	SLTDataType data;//数据
	struct SListNode* next;//指向下一个链表的地址
}SLTNode;

1.2 各函数的声明

//打印
void SLTPrint(SLTNode* phead);

//尾插
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 SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

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

2. 在SList.c中各函数的实现

2.1 打印 SLTPrint

打印一个单链表中的数据，我们只需要依次遍历每个节点，并打印其中的数据即可。

代码实现如下：

//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)//pcur != NULL
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

2.2 尾插 SLTPushBack

既然涉及到插入新节点，那我们就需要创建一个新节点，由于每次插入都需要创建新节点，所以我们设计一个新函数专门来创建新节点。

代码实现如下：

//创建新的节点
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

注意：

1. 每次malloc申请空间后应当检查是否申请成功。

2. 将新申请的节点的next指针置空。

现在，我们来对链表进行尾插，如果是空链表，那么插入的节点就是头节点；如果不是空链表，就找到链表的尾节点，然后将尾节点的next指针指向插入的新节点。

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead 就是指向第一个节点的指针
	//空链表和非空链表
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//ptail指向的就是尾结点
		ptail->next = newnode;
	}
}

2.3 头插 SLTPushFront

同样，实际到新节点的插入，我们需要调用上文中以及写好的创建新的节点的函数（SLTBuyNode），然后只需要将新申请的节点的next指针指向原来的头节点，然后让新申请的节点成为头节点即可。

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

2.4 尾删 SLTPopBack

删除操作同样需要考虑节点个数的问题，如果只有一个节点，释放空间，将头节点置空，如果有多个节点，需要使用双指针法先找到尾节点和前一个节点，然后释放尾节点并将前一个节点的next指针置空。

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL) //-> 优先级高于*
	{
		free(*pphead);
		*pphead = NULL;
	}
	else {
		//链表有多个节点

		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//prev ptail
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

2.5 头删 SLTPopFront

删除头节点时，我们需要记录第二个节点，然后释放头节点，最后使第二个节点成为头节点。

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;//->优先级高于*
	free(*pphead);
	*pphead = next;
}

2.6 查找 SLTFind

查找操作需要依次遍历一遍链表，如果找到了相关值，就返回该节点的指针，如果遍历结束都没有找到，就返回空指针。

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;//防止需要对链表进行多次遍历
	while (pcur)//等价于phead != NULL
	{
		if (pcur->data == x)
		{
			return pcur;//找到了，返回指针
		}
		pcur = pcur->next;
	}
	return NULL;//没找到的情况
}

2.7 在指定位置之前插入数据 SLTInsert

在指定位置之前插入同样需要考虑节点个数的问题，如果只有一个节点，头插即可；如果有多个节点，需要使用双指针法先找到pos节点和前一个节点，然后将新节点插入链表中。

//在任意位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);

	//若pos == *pphead 说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);//新建的节点的地址

		SLTNode* prev = *pphead;//pos的前一个节点
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		//prev -> newnode -> pos
		newnode->next = pos;//让新建的节点的next指针指向pos位置的节点
		prev->next = newnode;//让前一个节点的指针指向新建的节点的地址
	}
}

2.8 在指定位置之后插入数据 SLTInsertAfter

在指定位置之后插入数据仅需要将新节点插入到pos节点后即可。

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);//新建的节点的地址

	//pos -> newnode -> pos->next
	//先让newnode->next = pos->next
	newnode->next = pos->next;
	//再让pos->next = newnode
	pos->next = newnode;
}

2.9 删除节点 SLTErase

删除任意位置节点同样需要考虑节点个数的问题，如果只有一个节点，释放空间，将头节点置空，如果有多个节点，需要使用双指针法先找到pos节点和前一个节点，然后连接前后节点最后释放该节点。

//删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);

	if (*pphead == pos)//删除头节点的情况
	{
		//SLTNode* next = pos->next;
		//free(*pphead);
		//*pphead = next;
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

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

2.10 删除pos之后的节点 SLTEraseAfter

在指定位置之后插入数据仅需要连接前后节点，然后删除pos节点即可。

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);

	SLTNode* del = pos->next;//指向要删除的地址
	pos->next = del->next;
	free(del);
	del = NULL;
}

2.11 链表的销毁 SListDestroy

链表的销毁需要在遍历链表的过程中依次释放每一个节点，记录下需要释放的节点和下一个节点，然后释放该节点即可，直到链表为空，最后将头节点置空。

//链表的销毁
void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

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

三. 链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

链表的结构
带头	单向	循环
不带头	双向	不循环

链表说明：

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

单链表和双向带头循环链表

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

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

四. 参考代码

1. SList.h

单链表的结构体的定义和函数的声明

#pragma once

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

//定义节点的结构
//数据 + 指向下一个节点的指针
typedef int SLTDataType;

typedef struct SListNode 
{
	SLTDataType data;//数据
	struct SListNode* next;//指向下一个链表的地址
}SLTNode;

//打印
void SLTPrint(SLTNode* phead);

//尾插
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 SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

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

2. SList.c

具体函数的实现。

#include "SList.h"

//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)//pcur != NULL
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

//创建新的节点
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead 就是指向第一个节点的指针
	//空链表和非空链表
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//ptail指向的就是尾结点
		ptail->next = newnode;
	}
}

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL) //-> 优先级高于*
	{
		free(*pphead);
		*pphead = NULL;
	}
	else {
		//链表有多个节点

		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//prev ptail
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* next = (*pphead)->next;//->优先级高于*
	free(*pphead);
	*pphead = next;
}

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;//防止需要对链表进行多次遍历
	while (pcur)//等价于phead != NULL
	{
		if (pcur->data == x)
		{
			return pcur;//找到了，返回指针
		}
		pcur = pcur->next;
	}
	return NULL;//没找到的情况
}

//在任意位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);

	//若pos == *pphead 说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);//新建的节点的地址

		SLTNode* prev = *pphead;//pos的前一个节点
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		//prev -> newnode -> pos
		newnode->next = pos;//让新建的节点的next指针指向pos位置的节点
		prev->next = newnode;//让前一个节点的指针指向新建的节点的地址
	}
}


//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);//新建的节点的地址

	//pos -> newnode -> pos->next
	//先让newnode->next = pos->next
	newnode->next = pos->next;
	//再让pos->next = newnode
	pos->next = newnode;
}

//删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);

	if (*pphead == pos)//删除头节点的情况
	{
		//SLTNode* next = pos->next;
		//free(*pphead);
		//*pphead = next;
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

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

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);

	SLTNode* del = pos->next;//指向要删除的地址
	pos->next = del->next;
	free(del);
	del = NULL;
}

//链表的销毁
void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

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

3. test.c

单链表的测试代码，用来测试代码是否正确。

#include "SList.h"

//void SListTest01()
//{
//	//链表是由一个一个的节点组成
//	//创建几个节点
//	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
//	node1->data = 1;
//
//	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
//	node2->data = 2;
//
//	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
//	node3->data = 3;
//
//	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
//	node4->data = 4;
//
//	//将四个节点连接起来
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//
//	//调用链表的打印
//	SLTNode* plist = node1;
//	SLTPrint(plist);
//}

void SListTest02()
{
	//创建链表
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//测试尾插
	//SLTPushBack(NULL, 5);
	
	//测试头插
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 7);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 8);
	//SLTPrint(plist);

	测试尾删
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);

	测试头删
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);

	测试查找
	//SLTNode* find = NULL;
	//find = SLTFind(plist, 1);
	//if (find)
	//{
	//	printf("找到了!\n");
	//}
	//else
	//{
	//	printf("没有找到！\n");
	//}
	//find = SLTFind(plist, 5);
	//if (find)
	//{
	//	printf("找到了!\n");
	//}
	//else
	//{
	//	printf("没有找到！\n");
	//}

	测试前插入
	//SLTNode* find = NULL;
	//find = SLTFind(plist, 1);
	//SLTInsert(&plist, find, 7);
	//SLTPrint(plist);
	//find = SLTFind(plist, 4);
	//SLTInsert(&plist, find, 8);
	//SLTPrint(plist);

	测试后插入
	//SLTNode* find = NULL;
	//find = SLTFind(plist, 1);
	//SLTInsertAfter(find, 7);
	//SLTPrint(plist);
	//find = SLTFind(plist, 4);
	//SLTInsertAfter(find, 8);
	//SLTPrint(plist);

	测试删除
	//SLTNode* find = NULL;
	//find = SLTFind(plist, 1);
	//SLTErase(&plist, find);
	//SLTPrint(plist);
	//find = SLTFind(plist, 4);
	//SLTErase(&plist, find);
	//SLTPrint(plist);

	测试后删除
	//SLTNode* find = NULL;
	//find = SLTFind(plist, 1);
	//SLTEraseAfter(find);
	//SLTPrint(plist);
	//find = SLTFind(plist, 3);
	//SLTEraseAfter(find);
	//SLTPrint(plist);

	//测试销毁
	SListDestroy(&plist);
	SLTPrint(plist);
}

int main()
{
	//SListTest01();
	SListTest02();
	return 0;
}