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

已于 2023-01-06 21:11:42 修改
阅读量406 收藏 5
点赞数 5
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-01-06 20:33:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52347974/article/details/128553547
版权

一、什么是链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

二、链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向

在这里插入图片描述

  1. 带头或者不带头

在这里插入图片描述

  1. 循环或者非循环
    在这里插入图片描述

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

在这里插入图片描述

1.无头单向非循环链表： 结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表： 结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知感受到。

这里先实现无头单向非循环链表（简称单链表）。

三、单链表的实现

1、节点的结构体类型

节点分为数据域data和指针域next。

typedef int SLTDataType; //方便数据类型的整体更改
                        //后面int都是用这个来代替。
typedef struct SListNode
{
	SLTDataType	data;
	struct SListNode* next;
}SLTNode;

2、动态申请一个节点

malloc函数动态申请，申请成功则将数据域data赋值为x,将指针域next赋值为NULL。

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

3、打印单链表

如果单链表不为空，则将节点里的数据依次打印出来。

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

4、尾插（在尾部插入一个节点）

尾插就是要先动态开辟一个节点的空间，为这个节点赋值，然后将它连接到单链表的尾部。分为两种情况：第一种是单链表不为空的尾插，第二种是单链表为空的尾插。

在这里插入图片描述单链表为空时plist的值为NULL，这时不能对plist进行解引用操作，直接将要插入节点的地址赋给plist就行。单链表不为空时，要先找到最后一个节点，再将要插入的节点连接到它后面就行。

注意：

这里函数的形参变量pphead是一个二级指针，接收的是plist的地址，因为当被尾插的单链表为空时，进行尾插操作会使得plist的值发生改变，这时只有将plist的地址传给函数的形参，在函数体内进行插入操作时才会达到这个效果，后面函数的形参设计成二级指针都是因为这个原因。

//尾插
void SLTPushBack(SLTNode** pphead,SLTDataType x)
{
	SLTNode* newnode=BuySLTNode(x);
	//链表为空时
	if (*pphead ==NULL)
	{
		*pphead = newnode;
	}
	//链表不为空时
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next) //找到链表的最后一个节点
		{
			tail = tail->next;
		}
		tail->next = newnode;//将要插入的节点连接上去
	}
}

5、尾删（删除最后一个节点）

单链表为空时不能进行尾删操作，单链表只有一个节点时进行尾删操作，直接用free函数释放掉就行，但会使得plist的值发生改变，单链表不止一个节点时进行尾删操作，要先找到最后一个节点再将它用free函数释放掉。

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead); //判断单链表是否为空
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

6、头插（在单链表的头部插入一个节点）

单链表的头插是非常快的，任何情况下都能进行头插，并且每次头插都会使得plist的值发生改变。

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

7、头删（将单链表的第一个节点删除）

单链表为空时是不能进行头删的，单链表为非空时进行头删的操作都是一样的，并且每次头删都会引起plist值的改变。

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead);
	SLTNode* cur = *pphead;
	*pphead = cur->next;
	free(cur);
}

8、查找

如果找到则返回它的节点地址，否则返回NULL。

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;

9、pos位置后插入节点

只要pos的值不为NULL,就可以直接将要插入的节点插入到pos位置后，不需要从前往后找节点。

//某位置后插
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

10、pos位置前插入节点

首先，pos的值不能为NULL，其次pos位置前插分为两种情况，第一种，pos位置是第一个节点，那就相当于头插，第二种，pos位置不是第一个节点，那就需要从前往后找到pos位置的前一个节点，再进行插入操作。

//某位置前插
void SLTInsert(SLTNode** pphead,SLTNode* pos, SLTDataType x)
{
	assert(pos);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		newnode->next = prev->next;
		prev->next = newnode;
	}
}

11、删除pos位置后的一个节点

首先pos的值不能为NULL，其次删除pos位置后的一个节点分为两张情况，第一种，pos位置是最后一个节点，那就不需要删除操作，第二种，pos位置不是最后一个节点，那进行删除操作就行。

//某位置后删
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
	}
}

13、删除pos位置的节点

pos的值不能为NULL,pos位置是第一个节点时，相当于头删，pos位置为其它节点时，则需要从前往后找到pos位置的前一个节点，然后进行节点删除操作。

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next!=pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

12、销毁

如果单链表为空，就直接将pphead置为NULL，如果单链表不为空，就先将节点从前往后一个一个的free掉，最后将pphead置为NULL。

//销毁
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

四、完整代码

Slist.h

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

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType	data;
	struct SListNode* next;
}SLTNode;

//动态申请一个节点
SLTNode* BuySLTNode(SLTDataType x);

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

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//尾删
void SLTPopBack(SLTNode** pphead);

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//头删
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//某位置后插
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//某位置前插
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//某位置后删
void SLTEraseAfter(SLTNode* pos);

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);

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

Slist.c

#include"SList.h"

//动态申请一个节点
SLTNode* BuySLTNode(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 SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur !=NULL)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
		printf("NULL\n");
}

//尾插
void SLTPushBack(SLTNode** pphead,SLTDataType x)
{
	SLTNode* newnode=BuySLTNode(x);
	if (*pphead ==NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead); //判断单链表是否为空
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

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

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead);
	SLTNode* cur = *pphead;
	*pphead = cur->next;
	free(cur);
}

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

//某位置后插
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//某位置前插
void SLTInsert(SLTNode** pphead,SLTNode* pos, SLTDataType x)
{
	assert(pos);
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		newnode->next = prev->next;
		prev->next = newnode;
	}
}

//某位置后删
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
	}
}

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next!=pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

//销毁
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

Test.c

#include"SList.h"
//单链表部分函数的使用
int main()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 100);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);

	SLTPushFront(&plist, 200);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTPushFront(&plist, 300);
	SLTNode* pos=SLTFind(plist, 300);
	SLTInsert(&plist,pos, 400);
	SLTPrint(plist);

	pos = SLTFind(plist,400);
	SLTEraseAfter(pos);
	SLTPrint(plist);
	
	SLTDestroy(&plist);

	return 0;
}

下一篇将对带头双向循环链表进行讲解。

如有不足之处，欢迎大家随时指正。

星空之下-
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Python实现-无头单向非循环链表
12-22
无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的数据.（这个域叫数据域） ...
《简明数据结构》链表专题编程测验题13
Raider1的博客
01-05 350
数据结构链表——无头结点的单链表的建立，对单链表进行从小到大冒泡排序，交换单链表结点
链表学习之链表划分
阿渌的博客札记
02-18 771
整体思路就是，遍历一遍链表，把节点存入数组，对数组快排，然后再遍历数组，生成将节点重新连接。要求：调整之后节点的相对次序不变，时间复杂度不高于O(N)，空间复杂度不高于O(1)。将单向链表值划分为左边小、中间相等、右边大的形式。中间值为pivot划分值。注意处理，小于部分、等于部分、大于部分有缺失的情况。主要是使用6个指针记录3个部分的头、尾位置。但最容易想到和实现。
无头单向链表
Ljiyu0506的博客
06-14 401
链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 结构示意图：由前一个链表中的指针指向下一个链表的地址，在逻辑上是连续的。 优点：1. 无头单向链表可以轻松地插入或删除链表的头部和尾部，因为它不需要像有头链表一样先找到头部节点。 2. 在某些情况下，无头单向链表可以在空间上更加高效，因为它不需要额外的头节点。
【数据结构初阶】3. 单链表及OJ题
weixin_60915103的博客
01-03 203
文章包含：链表的相关概念和分类，单链表的代码实现，单链表中存在的缺陷以及单链表的OJ题
【算法基础】数据结构| 单链表+双链表 代码实现+图解+原理
Yaoyao2024的博客
03-17 2690
因为瑶瑶子正在备战蓝桥杯和校内ACM选拔赛，最近在学习算法相关的知识。我是借助AcWing网站来学习的，这篇文章是我学习就我学习内容的一个笔记，其中的一些对原理的解释是我学习过程中可能看到弹幕或者评论的小伙伴，觉得讲的很有道理醍醐灌顶，就引用过来了。这篇是关于数据结构，主要是利用数组模拟各种数据结构，主要是提高算法效率。对于一些比较晦涩难懂\让人头秃的地方，我习惯采用画图的方式来理解，所以你将看到我基于算法模板或题目精心绘制的图解，希望能帮助一起学算法的同学噢！
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
JavaScript数据结构之单链表和循环链表
11-30
在JavaScript中实现循环链表，可以在插入新节点时将最后一个节点的next指向新节点，并在插入第一个节点时将其next指向自身： ```javascript // 插入节点时 if (position === 0) { node.next = head; head = node;...
使用C++实现链表数据结构之单链表.zip
最新发布
03-13
链表是一种基础且重要的数据结构，它在计算机科学...单链表是链表的一个简单但实用的形式，它能帮助你理解更复杂链表结构，如双向链表和循环链表。通过实践这些基本操作，你可以更好地掌握链表在解决实际问题中的应用。
《简明数据结构》链表专题编程测验题1—— 逐个交叉方式合并两个单链表
Raider1的博客
01-04 345
试题描述分别建立两个有3个结点的单链表（有头结点），采用逐个交叉方式合并两个单链表，显示合并后的单链表。1.套用尾插法建立带头结点的链表模板 //尾插法建立带头结点的链表 LinkList CreateFromTail() /*将新增的字符追加到链表的末尾*/ { LinkList L; Node *r, *s; int flag = 1; L = (Node *)malloc(sizeof(Node)); /*为头结点分配存储空间*/ L->next = NULL
数据结构：双向链表（带头循环）
Yikefore的博客
05-11 1014
带头双向循环链表实现的详细介绍，带图解和完整的代码。
【数据结构】链式存储：链表（无头双向链表实现）
m0_72161237的博客
01-04 795
🌈节点由val域(数据域)，prev(前驱），next(后继)，对于prev域，其是引用类型，存放上一个节点的地址；对于next域，其是引用类型，存放下一个节点的地址。
数据结构与算法——双链表
cuc_pyx技术小站
09-28 858
数据结构与算法——双链表 文章目录数据结构与算法——双链表学习思路双链表的基本结构双链表的基本操作定义双链表——C++版插入结点在某个结点后插入元素在某个结点前插入元素记忆方法在头部插入元素s在尾部插入元素s删除结点遍历元素求长度双链表的进阶操作输出销毁头插法建表尾插法建表删除第i个元素在第i个元素后插入值为value的元素 学习思路 与单链表一样，我还是建议用过掌握基础操作来拼凑成大的操作。 双链表的基本结构 单链表指针域只有一个next指针，指向下一个结点，这就导致了它只能从前往后访问。为了弥补这一缺陷
[ 数据结构_C实现 ] 无头单向非循环链表的简单实现(单链表)
CSDN博客
03-15 1833
目录 1. 链表 1.1 链表的概念及结构 1.2链表的分类 1.3接口 2. 接口实现 2.1 节点的创建 2.2 打印链表 2.3 创建新节点 2.4尾插 2.5头插 2.6 尾删 2.7 头删 2.8查找 2.9在pos位置之前插入 2.10在pos位置之后插入 2.11 删除pos位置 2.12删除pos后面的值 3.菜单 1. 链表 1.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构...
《数据结构与算法》实验报告---单链表
m0_72056916的博客
12-20 3270
单链表实验报告包含实验源代码，实验运行结果，算法描述，算法流程图.......
数据结构链表之无头单向非循环链表的实现
Ly的博客
11-03 536
数据结构链表之无头单向循环链表的实现
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~
codewinter的博客
08-28 2375
文章目录（1）链表介绍1）为什么引入链表2）链表的概念及结构3）链表的分类（2）无头单向非循环链表的实现1）单链表的定义2）动态申请一个节点3）打印单链表4）单链表尾插5）单链表头插6）单链表尾删7）单链表头删8）在单链表中查找指定值的节点9）单链表在pos位置之后插入10）单链表删除指定pos位置的节点11）单链表删除指定pos位置之后的节点12）求单链表长度13）判断单链表是否为空12）求单链表长度13）判断单链表是否为空 学习链表之前，建议先学习下顺序表，配合这篇文章食用更佳哦： 【数据结构入门】顺序
【数据结构初阶】链表（上）——无头单向非循环链表的实现
m0_70811813的博客
11-02 432
链表、无头单向非循环链表的实现、无头单向非循环链表实现完整代码、运行测试
数据结构无头结点单向不循环链表（C语言版）
qq_45767476的博客
04-29 199
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;
数据结构课件：单链表与循环链表解析
"数据结构课件包含了关于单链表、循环链表、多项式相加、双向链表以及稀疏矩阵等主题的讲解。重点介绍了单链表的特点、存储映像、类定义以及插入和删除操作。" 在数据结构中，链表是一种重要的线性数据结构，它允许...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值