【数据结构初阶】链表（上）——无头单向非循环链表的实现

已于 2023-11-19 10:41:55 修改
阅读量366 收藏 5
点赞数 12
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
于 2022-11-02 20:14:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70811813/article/details/127651042
版权

目录

一、链表

        1.链表的概念及结构

        2.链表的分类

                <2.1>单向链表和双向链表

                <2.2>带头节点链表和不带头节点链表

               <2.3>循环和非循环链表

二、无头单向非循环链表的实现

        1.创建无头单向非循环链表的节点

        2.为无头单向非循环链表添加数据

                <2.1>在链表尾部插入数据

                <2.2>在链表头部插入数据

                <2.3>在链表pos节点位置之后插入数据

        3.为无头单向非循环链表删除数据

                <3.1>在链表尾部删除数据

                <3.2>在链表头部删除数据 

                <3.3>在链表pos节点之后删除数据

        4.遍历链表

        5.在链表中查找数据

        6.销毁链表

 三、无头单向非循环链表实现完整代码

四、运行测试

经过上期博客的学习我们发现顺序表存在着一些缺陷：

        > 扩容时有一定的代价，尤其是异地扩容时。其次还会造成空间的浪费（空间碎片的产生）。

        > 从头部或中间插入（删除）数据时需要挪动其他数据，效率低下。

那我们是否有一种可以按需申请释放内存、在插入删除数据时不挪动数据的存储方式呢？

链表就很好的解决了以上问题：

一、链表

        1.链表的概念及结构

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

        下面是链表的模拟图：

        我们每次要存储要存储数据时需要向系统空间的堆区申请所存储数据外加一个指针的大小的空间（我们称这样一个大小的空间叫做节（结）点），其中指针空间所存的是下一个节点的地址（如果该节点后无节点该指针指向的地址则为空）。

从上图可看出：

        1.链式结构在逻辑上是连续的，但是在物理上不一定连续。

        2.现实中的结点一般都是从堆上申请出来的。

        3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

        2.链表的分类

                <2.1>单向链表和双向链表

                <2.2>带头节点链表和不带头节点链表

               <2.3>循环和非循环链表

         虽然链表的种类很多，但是我们最常用的是无头单向非循环链表和带头双向循环链表：

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

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

下面我们来对无头单向非循环链表来进行实现：

二、无头单向非循环链表的实现

在实现单链表之前我们先要确定节点类型：

typedef int SLTDataType;//数据类型
typedef struct SListNode//节点类型
{
	SLTDataType Data;//数据
	struct SListNode* next;//节点指针
}SListNode;

         注：这里的对int类型进行重定义是为了我们更好的看懂Data只是一种数据而不仅仅是int类型。所以我们在使用链表时存储的数据并不限制于int类型，这里仅仅是举例。

        1.创建无头单向非循环链表的节点

SListNode* BuySListNode(SLTDataType x)//x传入要添加的数据
{
	SListNode* p = (SListNode*)malloc(sizeof(SListNode));//为单链表创建一个节点的空间
	if (p == NULL)//判断堆区空间是否申请成功
	{
		perror("malloc");
		exit(-1);
	}
	p->Data = x;//拷贝数据
	p->next = NULL;//由于没有下一个节点，将节点指针置为空
	return p;
}

        2.为无头单向非循环链表添加数据

                <2.1>在链表尾部插入数据

void SListPushBack(SListNode** pplist, SLTDataType x)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	if (*pplist == NULL)//如果传入的是个空链表就直接插入一个新节点
	{
		*pplist = newplist;
		return;
	}
	//传入的不是空链表就找到链表尾部
	SListNode* tail = *pplist;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next = newplist;//在链表尾部插入数据
}

                <2.2>在链表头部插入数据

void SListPushFront(SListNode** pplist, SLTDataType x)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	newplist->next = *pplist;//将节点插入到链表头部
	*pplist = newplist;//将链表的头指针指向插完节点后的新链表
}

                <2.3>在链表pos节点位置之后插入数据

void SListInsertAfter(SListNode** pos, SLTDataType x)//pos传入要插入其后的节点的位置的地址
{
	assert(*pos);
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	newplist->next = (*pos)->next;//将新节点之后指向的节点向插入
	(*pos)->next = newplist;//再将新节点插入pos节点之后的位置
}

        3.为无头单向非循环链表删除数据

                <3.1>在链表尾部删除数据

void SListPopBack(SListNode** pplist)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	assert(*pplist);//传入的指针不能为空
	if ((*pplist)->next == NULL)//如果此链表只有一个节点,就直接直接释放
	{
		free(*pplist);
		*pplist = NULL;
		return;
	}
	SListNode* tail = *pplist;
	SListNode* temp = *pplist;//记录尾节点前一个节点的位置
	//找到链表尾部
	while (tail->next)
	{
		temp = tail;//记录尾节点前一个节点的位置
		tail = tail->next;
	}
	free(tail);//释放链表尾部节点的空间
	tail = NULL;//将节点置空防止野指针的产生
	temp->next = NULL;//将尾节点前一个节点的指针置空
}

                <3.2>在链表头部删除数据 

void SListPopFront(SListNode** pplist)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	assert(*pplist);//传入的指针不能为空
	SListNode* Del = *pplist;//记录头节点的地址
	*pplist = (*pplist)->next;//将头节点从链表中销毁
	free(Del);
	Del = NULL;//防止野指针的产生
}

                <3.3>在链表pos节点之后删除数据

void SListEraseAfter(SListNode** pos)//pos传入要删除其后的节点的位置的地址
{
	assert(*pos);//传入的指针不能为空
	SListNode* Del = (*pos)->next;//记录要删除节点的地址
	(*pos)->next = Del->next;//将要删除节点从链表中销毁
	Del->next = NULL;//防止free时释放整个链表空间
	free(Del);
	Del = NULL;//防止野指针的产生
}

        4.遍历链表

void SListPrint(SListNode* plist)
{
	while (plist)//一直遍历到空为止
	{
		printf("%d->", plist->Data);
		plist = plist->next;
	}
	printf("NULL\n");
}

        5.在链表中查找数据

SListNode* SListFind(SListNode* plist, SLTDataType x)
{
	SListNode* find = plist;
	while (find)
	{
		if (find->Data == x)
			return find;//找到返回其地址
		find = find->next;
	}
	return NULL;//没找到返回NULL
}

        6.销毁链表

void SListDestroy(SListNode** plist)
{
	assert(*plist);//传入的指针不能为空
	SListNode* Del = *plist, * temp = *plist;
	while (Del)//释放整个链表
	{
		temp = temp->next;
		free(Del);
		Del = temp;
	}
	*plist = NULL;//置空指针防止野指针的产生
}

 三、无头单向非循环链表实现完整代码

typedef int SLTDataType;//数据类型
typedef struct SListNode//节点类型
{
	SLTDataType Data;//数据
	struct SListNode* next;//节点指针
}SListNode;


//创建一个单链表
SListNode* BuySListNode(SLTDataType x)//x传入要添加的数据
{
	SListNode* p = (SListNode*)malloc(sizeof(SListNode));//为单链表创建一个节点的空间
	if (p == NULL)//判断堆区空间是否申请成功
	{
		perror("malloc");
		exit(-1);
	}
	p->Data = x;//拷贝数据
	p->next = NULL;//由于没有下一个节点，将节点指针置为空
	return p;
}
// 单链表打印
void SListPrint(SListNode* plist)
{
	while (plist)
	{
		printf("%d->", plist->Data);
		plist = plist->next;
	}
	printf("NULL\n");
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	if (*pplist == NULL)//如果传入的是个空链表就直接插入一个新节点
	{
		*pplist = newplist;
		return;
	}
	//传入的不是空链表就找到链表尾部
	SListNode* tail = *pplist;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next = newplist;//在链表尾部插入数据
}
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDataType x)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	newplist->next = *pplist;//将节点插入到链表头部
	*pplist = newplist;//将链表的头指针指向插完节点后的新链表
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	assert(*pplist);//传入的指针不能为空
	if ((*pplist)->next == NULL)//如果此链表只有一个节点,就直接直接释放
	{
		free(*pplist);
		*pplist = NULL;
		return;
	}
	SListNode* tail = *pplist;
	SListNode* temp = *pplist;//记录尾节点前一个节点的位置
	//找到链表尾部
	while (tail->next)
	{
		temp = tail;//记录尾节点前一个节点的位置
		tail = tail->next;
	}
	free(tail);//释放链表尾部节点的空间
	tail = NULL;//将节点置空防止野指针的产生
	temp->next = NULL;//将尾节点前一个节点的指针置空
}

// 单链表头删
void SListPopFront(SListNode** pplist)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
	assert(*pplist);//传入的指针不能为空
	SListNode* Del = *pplist;//记录头节点的地址
	*pplist = (*pplist)->next;//将头节点从链表中销毁
	free(Del);
	Del = NULL;//防止野指针的产生
}
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDataType x)
{
	assert(plist);
	SListNode* find = plist;
	while (find)
	{
		if (find->Data == x)
			return find;//找到返回其地址
		find = find->next;
	}
	return NULL;//没找到返回NULL
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode** pos, SLTDataType x)//pos传入要插入其后的节点的位置
{
	assert(*pos);
	SListNode* newplist = BuySListNode(x);//创建一个新节点为插入链表做准备
	newplist->next = (*pos)->next;//将新节点之后指向的节点向插入
	(*pos)->next = newplist;//再将新节点插入pos节点之后的位置
}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode** pos)//pos传入要删除其后的节点的位置
{
	assert(*pos);//传入的指针不能为空
	SListNode* Del = (*pos)->next;//记录要删除节点的地址
	(*pos)->next = Del->next;//将要删除节点从链表中销毁
	Del->next = NULL;//防止free时释放整个链表空间
	free(Del);
	Del = NULL;//防止野指针的产生
}
// 单链表的销毁
void SListDestroy(SListNode** plist)
{
	assert(*plist);//传入的指针不能为空
	SListNode* Del = *plist, * temp = *plist;
	while (Del)//释放整个链表
	{
		temp = temp->next;
		free(Del);
		Del = temp;
	}
	*plist = NULL;//置空指针防止野指针的产生
}

四、运行测试

测试代码：

int main()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPrint(plist);
	SListPushBack(&plist, 2);
	SListPrint(plist);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SListPopBack(&plist);
	SListPrint(plist);
	SListPopFront(&plist);
	SListPrint(plist);
	SListPopBack(&plist);
	SListPrint(plist);
	SListPushBack(&plist, 10);
	SListPrint(plist);
	SListPushFront(&plist, 100);
	SListPrint(plist);
	SListPushBack(&plist, 200);
	SListPrint(plist);
	SListPushBack(&plist, 400);
	SListPrint(plist);
	SListNode* temp = SListFind(plist, 100);
	SListEraseAfter(&temp);
	SListPrint(plist);
	temp = SListFind(plist, 200);
	SListInsertAfter(&temp, 300);
	SListPrint(plist);
	SListDestroy(&plist);
	SListPrint(plist);
	return 0;
}

运行效果：

        好了，本期博客到这里又要结束了，本期博客代码量多难免有不足之处，还请各位大佬们在评论区不吝赐教！

        下期还会对链表进行详细讲解，请各位看官敬请期待~

1e-12
关注
  • 12
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
链表-使用PHP实现的循环链表数据结构.zip
03-13
链表 链表_使用PHP实现的循环链表数据结构
【数据结构与算法】 - (不带头结点)单链表详细实现思路及代码(C/C++语言)
wkd_007的博客
03-26 4870
文章先介绍 “头结点” 在链表的作用，以及 “有头结点” 和 “无头结点” 的区别，然后再详细介绍了“无头结点链表” 的实现步骤，最后给出了 “无头结点单链表” 的C语言实现代码，同时也给出了 “有头结点单链表” 的C语言实现代码。读者可以对比这两份代码，将会对单链表的“头结点”有非常深刻的理解。
[数据结构]无头结点单链表JAVA
最新发布
qq_52221190的博客
03-11 126
无头结点单链表JAVA
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的数据.（这个域叫数据域） 存储一个下一个（后继）数据元素的信息（Next）（这个域叫指针域） Python实现 class Node: def __init__(self, data): """ 初始化链表：data相当于链表的数据域，next相当于链表的指针 :param data:存储数据本身 """
数据结构：单向链表（无头非循环）
Yikefore的博客
04-22 766
数据结构：单向无头非循环链表的详细介绍以及实现过程。
数据结构 ——(无头)单链表的结构、功能（增删查改）。
wihkum
07-11 364
数据结构 ——(无头)单链表的结构、功能（增删查改）。
无头单向链表
Ljiyu0506的博客
06-14 358
链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 结构示意图：由前一个链表中的指针指向下一个链表的地址，在逻辑上是连续的。 优点：1. 无头单向链表可以轻松地插入或删除链表的头部和尾部，因为它不需要像有头链表一样先找到头部节点。 2. 在某些情况下，无头单向链表可以在空间上更加高效，因为它不需要额外的头节点。
数据结构无头结点单向不循环链表（C语言版）
qq_45767476的博客
04-29 194
main.c(负责测试） #include <stdlib.h> #include <stdio.h> #include <time.h> #include "nohead.h" int main() { LNode *list = NULL; struct score_st data[10],mydata,data1; int i = 0; srand((unsigned)time(NULL)); //初始化数组 for (i = 0; i < 10;
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~
codewinter的博客
08-28 2247
文章目录（1）链表介绍1）为什么引入链表2）链表的概念及结构3）链表的分类（2）无头单向非循环链表的实现1）单链表的定义2）动态申请一个节点3）打印单链表4）单链表尾插5）单链表头插6）单链表尾删7）单链表头删8）在单链表中查找指定值的节点9）单链表在pos位置之后插入10）单链表删除指定pos位置的节点11）单链表删除指定pos位置之后的节点12）求单链表长度13）判断单链表是否为空12）求单链表长度13）判断单链表是否为空 学习链表之前，建议先学习下顺序表，配合这篇文章食用更佳哦： 【数据结构入门】顺序
数据结构：线性表之-单向链表(无头)
2301_77649794的博客
09-05 1174
单向链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只能访问它后面的节点，而不能访问前面的节点。每个节点包含数据和指向下一个节点的指针。最后一个节点的指针指向空值（NULL），表示链表的结束。可以动态地添加或删除节点，链表的长度可以根据需要进行扩展或缩小。可以根据指针迅速插入或删除节点，而不需要移动其他节点。优点：插入和删除元素的时间复杂度为O(1)，不需要像数组一样进行元素的移动；链表长度可以动态调整，没有固定大小的限制。
链表详解（一）—— 无头单向非循环链表
2021dragon的博客
04-08 2782
文章目录链表介绍初始化链表打印单链表增加数据单链表的头插单链表的尾插删除数据单链表的头删单链表的尾删 链表介绍 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 实际中，链表的结构多种多样： 1、带头，不带头。 2、单向，双向。 3、循环，非循环。 通过以上的这些情况组合起来，就有八种
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C数据结构循环链表实现约瑟夫环
01-01
C数据结构循环链表实现约瑟夫环 本文代码均在turbo C 2.0 的环境下运行通过，并得到正确结果，本程序为用循环链表实现约瑟夫环，即有m个人站成一个圆环，从某人（队列第一个）开始报数，约定从某数开始的第n个人出列...
【C＋＋】单链表（入门级别最简单的无头单向非循环表）
weixin_71138261的博客
11-06 405
【C＋＋】单链表（入门级别最简单的无头单向非循环表）
数据结构的无头单向链表
Thewei666的博客
11-08 456
无头单向链表的数据元素之间逻辑上的线性关系通过在节点中专用的指针来体现，每个节点包含两部分一部分为数据，另一部分为指针。存储数据元素信息值的为数据域，存放其后继节点地址指针的为指针域单纯单链表增删查改的意义不大，它更多的是去做更复杂结构的子结构，链表存储数据还得看双向链表单链表不适合在pos前插入数据，它适合在pos后插入数据。
无头节点--单链表
qq_53010164的博客
04-01 1678
目录 一、单链表打印： 二、增容 三、单链表尾插 四、单链表头插 五、单链表尾删 六、单链表头删 七、单链表的查找 八、单链表在pos之后插入X 九、单链表在pos之前插入X 十、删除pos位置 十一、删除pos之后的位置 十二、销毁链表 总代码： Slistexe.h Slistexe.c test.c 部分运行结果：​ 一、单链表打印： //打印 void SListprint(SL* phead) { SL* cur = phead; whil...
【数据结构】单链表（无头单向非循环链表）的实现
m0_52347974的博客
01-06 382
单链表
图解无头单向非循环链表【数据结构】
Tau_Ceti的博客
03-14 1207
0.前言🐑 🌵🌵 大家好啊，2天不见，甚是想念，呜呜网课要结束了，今天就要开始线下上课了，ε=(´ο｀*)))唉，美好生活不复返了。话不多说，今天开始回顾链表中的无头单向非循环链表。 🌵🌵 本节重点： 链表&顺序表对比 单链表各个接口的实现 1.链表 🐱 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 关于顺序表的不足： 扩容有性能消耗且有可能存在空间浪费。 扩容时，如果扩小了，大量插入数据时，频繁扩容，性能消耗较大；如果扩大
数据结构与算法单向循环链表
09-20
单向循环链表是一种特殊的链表，它与单链表相似，唯一的区别是最后一个节点指向链表的头节点，形成一个环。这种结构可以用来解决需要循环访问的问题，比如约瑟夫环问题。在单向循环链表中，每个节点除了保存数据元素本身的信息外，还保存了指向下一个节点的指针。这样就可以通过遍历从一个节点到达下一个节点，并且当遍历到最后一个节点时，可以通过指向头节点的指针回到链表的起始位置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1e-12

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值