【数据结构】单链表（不带头结点）基本操作的实现（C语言）

已于 2023-07-06 16:16:50 修改
阅读量992 收藏 17
点赞数 31
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
于 2022-11-12 21:09:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53943591/article/details/127705136
版权

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🐌 个人主页：蜗牛牛啊
🔥 系列专栏：🛹数据结构、🛴C++
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

文章目录

通过对顺序表的学习，我们可以发现顺序表有以下几点缺陷：
1.空间不够时需要扩容，扩容尤其是用realloc进行异地扩容时，是有一定代价的，其次还可能存在一定空间浪费。
2.头部或者中间插入删除，需要挪动数据，效率低下。
那我们可以对其所具有的缺陷进行优化：可以按需申请空间同时插入删除时不挪动数据。而单链表就符合这些优化所具有特点。但是我们要注意的是单链表具有这些优点并不代表链表就可以完全替代顺序表。

一、单链表的概念

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

单链表从上图可以看出，链式结构在逻辑上是连续的，但是在物理上不一定连续，物理结构中指针域存储的是下一个结点的地址；而且链式结构的结点一般都是从堆上申请出来的；从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。链表存储数据的区域可分为数据域和指针域：

结构

用代码表示链表中的数据域和指针域如下：

typedef int STLDataType;//typedef定义数据类型
typedef struct SListNode
{
	SLTDataType data;//结点的数据
    //STLNode* next;//不能这样定义，typedef定义在这里还没起作用，这里不能用
	struct SListNode* next;//next指针指向下一个结点
}STLNode;

思考：为什么在申请的时候需要申请堆上的空间？因为堆上申请的空间存储数据的时候不会因为函数销毁而销毁，堆上的空间需要的时候就申请，不需要的时候就释放；函数栈帧上开辟的空间存储的数据会因为函数栈帧的销毁而释放，后面在进行尾插和头插时候新的结点不能链接到表上。

二、单链表的基本操作

我们在创建链表结点的时候不能使用下面这种方式：

void TestSList
{
    SLTNode node;
}

因为node是在TestSList函数内创建的，属于局部变量，局部变量作用域仅限于函数内，出函数作用域就失效了，函数结束的时候会被销毁。

如当我们往链表中插入结点时使用SLTNode node往链表中插入结点，结点存在栈帧中，函数结束局部变量就销毁了。

1.创建单个结点

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//申请空间
	if (newnode == NULL)//判断是否为空
	{
		perror("BuySLTNode malloc");
		exit(-1);
	}
	newnode->val = x;//赋值
	newnode->next = NULL;//next指针指向空
	return newnode;//返回创建的结点
}

2.创建具有n个结点的链表

SLTNode* CreateSList(int n) 
{
	int i = 0;
	SLTNode* ptail = NULL,*phead = NULL;
	for (i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i); //创建新节点
		if (phead == NULL)
		{
			ptail = phead = newnode;
		}
		else
		{
			ptail->next = newnode; //链接
			ptail = newnode;
		}
	}
	return phead; //返回头节点
}
//没有返回值，形参使用的是二级指针改变头指针指向的地址。
//void CreateSList(SLTNode** pphead, int n)
//{
//	int i = 0;
//	SLTNode* ptail = NULL;
//	for (i = 0; i < n; i++)
//	{
//		SLTNode* newnode = BuySLTNode(i);
//		if (*pphead == NULL)
//		{
//			ptail = *pphead = newnode;
//		}
//		else
//		{
//			ptail->next= newnode;
//			ptail = newnode;
//		}
//	}
//}

上述代码中提供了两种实现方式，没有注释的是返回头指针的，注释内容是没有返回值，形参使用的是二级指针改变头指针指向的地址。

3.打印单链表

void SLTPrint(SLTNode* phead)
{
	SLTNode* tail = phead;
    //遍历链表
	while (tail)
	{
		printf("%d ", tail->val);
		tail = tail->next;
	}
	printf("\n");
}

4.尾插

//必须传二级指针，这样当头节点为空时能够改变头节点
void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* tail = *pphead; 
	SLTNode* newnode = BuySLTNode(x); //申请新结点
	if (*pphead == NULL) //如果链表为空
	{
		*pphead = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

尾插时，要注意当单链表的头结点为空的时候，要先将新结点作为头结点。因为当头结点为空时，需要改变头指针，所以传过来的为二级指针（也可以使用一级指针，不过此时要有返回值），要想改变SLTNode*的值，就要传递它的地址即SLTNode**类型，如果只传SLTNode*指针无法改变头节点，因为形参的改变不会影响到实参。

5.尾删

//传二级指针，如果只剩头节点时能够有效删除头节点
void SLTPopBack(SLTNode** pphead)//尾删
{
	assert(*pphead);//判断链表不为空
	if ((*pphead)->next==NULL)
	{
		free(*pphead);//释放空间
		*pphead = NULL;//置空
	}
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
        //遍历找到最后一个结点
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);//将最后一个结点的空间释放
		prev->next = NULL;//置空
	}
}

尾删时也要注意区分是否为头结点；同时注意删除后，要将其置空prev->next = NULL。

6.头插

//头插时也要注意是不是头节点为空，传二级指针
void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	SLTNode* newnode = BuySLTNode(x);//申请新节点
	newnode->next = *pphead;
	*pphead = newnode;
}

7.头删

void SLTPopFront(SLTNode** pphead)//头删
{
	assert(*pphead);//断言
	SLTNode* nextnode = (*pphead)->next;//记录头节点的下一个结点
	free(*pphead);//释放空间
	*pphead = nextnode;//头节点为下一个结点
}

头插和头删是单链表的优势，尾插和尾删是顺序表的优势。同时在尾删时注意将*pphead加上括号用来区分优先级，否则会报错。

8.查找某个结点

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)//查找某个数并返回所在位置
{
	SLTNode* tail = phead;
    //遍历
	while (tail)
	{
		if (tail->val == x)
		{
			return tail;
		}
		tail = tail->next;
	}
	return NULL;
}

注意循环条件，当循环条件写为while(tail->next)时，会有空指针的风险，同时还会漏掉最后一个结点。

9.在某个结点后面插入

void SLInsertAfter(SLTNode* pos, SLTDataType x)//在某个结点的后面插入某个数
{
	assert(pos);//断言
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* tail = pos->next;
    //插入新节点
	pos->next = newnode;
	newnode->next = tail;
}

10.在某个结点前面插入

void SLTInsert(SLTNode** pphead,SLTNode* pos, SLTDataType x)//在某个结点的前面插入某个数
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
    //如果pos是头节点，调用头插函数
	if (pos == *pphead)
	{
		/*newnode->next = *pphead;
		*pphead = newnode;*/
		SLTPushBack(pphead, x);
	}
	else
	{
        //遍历然后插入结点
		SLTNode* tail = *pphead;
		while (tail->next != pos)
		{
			tail = tail->next;
		}
        //插入结点
		tail->next = newnode;
		newnode->next = pos;
	}
}

11.删除某个位置后面的结点

void SLTEraseAfter(SLTNode* pos)//删除pos位置之后的那个位置
{
	assert(pos);
    //结点后面为空结点，直接返回
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
        //删除
		SLTNode* tail = pos->next;
		pos->next = tail->next;
		free(tail);//释放空间
	}
}

12.删除某个结点

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

13.销毁单链表

void SLTDestroy(SLTNode** pphead)//销毁
{
	assert(*pphead);
	SLTNode* tail = *pphead;
	
    //遍历，一个一个销毁
	while (tail)
	{
		SLTNode* next = tail->next;
		free(tail);
		tail = next;
	}
	*pphead = NULL;
}

注意最后要将头结点置空。

三、测试代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDataType;
typedef struct SList {
	struct Slist* next;
	SLTDataType val;
}SLTNode;
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("BuySLTNode malloc");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}
SLTNode* CreateSList(int n)
{
	int i = 0;
	SLTNode* ptail = NULL, * phead = NULL;
	for (i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		if (phead == NULL)
		{
			ptail = phead = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}
//void CreateSList(SLTNode** pphead, int n)
//{
//	int i = 0;
//	SLTNode* ptail = NULL;
//	for (i = 0; i < n; i++)
//	{
//		SLTNode* newnode = BuySLTNode(i);
//		if (*pphead == NULL)
//		{
//			ptail = *pphead = newnode;
//		}
//		else
//		{
//			ptail->next= newnode;
//			ptail = newnode;
//		}
//	}
//}
void SLTPrint(SLTNode* phead)
{
	SLTNode* tail = phead;
	while (tail)
	{
		printf("%d ", tail->val);
		tail = tail->next;
	}
	printf("\n");
}
void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* tail = *pphead;
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		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;
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}
}
void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SLTPopFront(SLTNode** pphead)//头删
{
	assert(*pphead);
	SLTNode* nextnode = (*pphead)->next;
	free(*pphead);
	*pphead = nextnode;
}
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)//查找某个数并返回所在位置
{
	SLTNode* tail = phead;
	while (tail)
	{
		if (tail->val == x)
		{
			return tail;
		}
		tail = tail->next;
	}
	return NULL;
}
void SLInsertAfter(SLTNode* pos, SLTDataType x)//在某个结点的后面插入某个数
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* tail = pos->next;
	pos->next = newnode;
	newnode->next = tail;
}
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//在某个结点的前面插入某个数
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	if (pos == *pphead)
	{
		/*newnode->next = *pphead;
		*pphead = newnode;*/
		SLTPushBack(pphead, x);
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		tail->next = newnode;
		newnode->next = pos;
	}
}
void SLTEraseAfter(SLTNode* pos)//删除pos位置之后的那个位置
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* tail = pos->next;
		pos->next = tail->next;
		free(tail);
	}
}
void SLTErase(SLTNode** pphead, SLTNode* pos)//删除pos位置
{
	assert(pos);
	SLTNode* tail = *pphead;
	if (pos == *pphead)
	{
		SLTNode* nextNode = (*pphead)->next;
		free(*pphead);
		*pphead = nextNode;
	}
	else
	{
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		tail->next = pos->next;
		free(pos);
	}
}
void SLTDestroy(SLTNode** pphead)//销毁
{
	assert(*pphead);
	SLTNode* tail = *pphead;

	while (tail)
	{
		SLTNode* next = tail->next;
		free(tail);
		tail = next;
	}
	*pphead = NULL;
}
void TestSL()
{
	SLTNode* plist = CreateSList(2);
	/*SLTNode* plist = NULL;
	CreateSList(&plist,10);//没有返回值
	SLTPrint(plist);*/
	SLTPushBack(&plist, 600);
	SLTPushBack(&plist, 200);
	SLTPushBack(&plist, 300);
	SLTPushBack(&plist, 400);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPrint(plist);

	SLTPushFront(&plist, 100);
	SLTPushFront(&plist, 200);
	SLTPushFront(&plist, 300);
	SLTPushFront(&plist, 400);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTNode* pos = SLTFind(plist, 600);
	if (pos)
	{
		SLInsertAfter(pos, 700);
		SLTInsert(&plist, pos, 500);
		SLTEraseAfter(pos);
		//SLTErase(&plist, pos);

	}
	SLTPrint(plist);
	SLTDestroy(&plist);
	SLTPrint(plist);
}
int main()
{
	TestSL();
	return 0;
}
不 良
关注
  • 31
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 26
    评论
专栏目录
不带头结点的单链表c语言,不带头结点的单链表的实现（C语言）
weixin_42297675的博客
05-21 1575
不带头结点的单链表的实现(C语言)不带头结点的单链表的实现(C语言)链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表(单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作...
单链表（带头结点）.cpp
08-01
实现单链表及其一些基本操作函数（带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素...
【数据结构】C语言实现单链表（带头结点）
SHLYYY
05-04 1892
SLLWNode;// 在pos之前插入 void SLLWInsert(SLLWNode * phead , SLLWNode * pos , SLLWDataType x);// 在pos之后插入 void SLLWInsertAfter(SLLWNode * pos , SLLWDataType x);// 删除pos位置的值 void SLLWErase(SLLWNode * phead , SLLWNode * pos);
数据结构之不带头结点单链表和带头结点单链表相关操作实现（C语言）
qq_51883718的博客
10-23 1457
数据结构之不带头结点单链表和带头结点单链表相关操作实现（C语言）
C语言不带头结点的单链表
qq_45421602的博客
07-22 2194
不带头节点的单链表，包含头插尾插，及头删尾删，链表逆序
带头结点的单链表的操作实现（C语言）
加啊啊啊啊零的博客
09-04 2364
补充知识： 链式存储结构存储线性表：把存储有数据元素的结点用指针域构造成链。 指针：指向物理存储单元地址的变量。 结点：一个由数据元素域及一个或若干个指针域组成的结构体。 单链表的定义 链式存储结构的线性表称为链表。根据指针域的不同和结点构造链的方法不同，链表主要有单链表、单循环链表和双循环链表三种。其中，单链表——构造链表的结点只有一个指向直接后继结点的指针域。 单链表的表示： 单链表中每个结点的结构 单链表分为带头结点结构和不带头结点结构两种。 我们把指向单链表的指...
【数据结构】C语言实现单链表的基本操作
蒙奇D索大的博客
12-28 1485
【数据结构】第二章——线性表(6) 详细介绍了通过C语言实现单链表的基本操作……
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 2776
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 2083
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
单链表（不带头结点）的基本操作
热门推荐
H643511的博客
10-08 1万+
不带头节点的单链表1、操作实现1.1单链表的定义1.2初始化单链表1.3得到单链表表长1.4单链表的判空操作1.5建立单链表1.5.1头插法1.5.2尾插法1.6按值查找结点1.6.1得到一个结点1.6.2得到该结点的位置1.7按位查找结点1.7.1得到一个结点1.7.2得到该位置结点的数据1.8插入数据1.9删除数据1.10输出表中数据1.11清空表2、全部代码        相对于带头结点的单链表对每一个结点的操作比较统一，不带头结点
数据结构之单链表的基本操作-C语言实现
qq_57066758的博客
07-06 74
数据结构之单链表的基本操作与实现
数据结构第二章作业答案参考（C语言）
02-05
2. （共15分）已知带头结点的单循环链表L，编写算法实现删除其中所有值为e 的数据元素结点。 （要求：类型定义、算法描述和算法时间复杂度分析） 类型定义：（3分） typedef struct LNode{ ElemType data; ...
数据结构（C语言版）综合实践集合运算
04-01
设有两个带头结点的单循环链表存储的集合A、B，其元素类型为字符或者整形，且以非递减方式存储，其头结点分别为ha、hb。要求下面各问题中的结果集合同样以非递减方式存储，结果集合不影响原集合。 2.实现要求： ⑶ ...
数据结构第5次作业.docx
05-03
3.算法设计：带附加头结点单链表将各数据结点按关键字升序连接。 4.编程题：键盘输入n个无符号整数，用链式基数排序实现由小到大排序，输出排序结果。 提示：对于C语言32bit宽的unsigned类型，可以采用16进制形式来...
数据结构上机实例 通讯录管理 C语言
12-13
实现功能：用带头结点的单链表作存储结构，实现通讯录单链表的建立、通讯者的插入、删除、查询以及通讯录链表的输出功能。  实验机时：6  设计要求： 为了实现通讯录管理的操作功能，首先设计一个含有多个...
【数据结构】链式二叉树详解
最新发布
s_little_monster的博客
06-03 2532
链式二叉树的实现
线性数据结构-数组
passworddddddd的博客
05-31 212
因为数组定长，当想往长度为8的数组中添加第九个元素时，操作系统会开辟一段长度为16的新的空间（操作系统会开辟一些提前量，多划一些空间），然后将旧数组的八个元素复制到新的数组中，并将新添加的元素，添加到新数组的第九个位置上，并且销毁就数组。1、因为空间必须是连续的，如果数组比较大，当系统的空间碎片较多时，容易存不下。在长度8的数组中删除第5个元素，不改变数组长度，从第六个元素开始向左移动一个单元，即数组删除。2、因为数组长度是固定，所以数组的内容难以被添加和删除。3、数组的变量指向了数组第一个元素的位置。
C语言.数据结构.单链表
Joseit的博客
05-31 776
C语言数据结构单链表技术博客文章摘要 本文深入探讨了C语言中的数据结构——单链表。首先，文章介绍了链表的概念及结构，强调了链表作为一种物理存储结构上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。通过将链表与火车车厢的类比，形象地展示了链表节点之间的独立性和链接关系。 接着，文章详细阐述了单链表的实现方法，包括定义链表节点结构体、实现基本的链表操作（如头部插入、删除、尾部插入、删除、查找、在指定位置插入/删除节点等），以及链表的销毁等功能。
软设之希尔排序
2301_81968528的博客
05-30 284
假设有n个元素，先取一个小于n的整数d1作为一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组中进行直接插入排序;然后，取第二个增量d2
单链表不带头结点，需要对其进行什么特殊操作
06-06
如果单链表不带头结点，则在进行插入、删除等操作时需要对第一个节点进行特殊处理。 在插入节点时，如果要在第一个节点...由于单链表不带头结点的特殊处理较为繁琐，因此通常建议使用带头结点的单链表来实现链表操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不 良

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

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

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

打赏作者

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

抵扣说明：

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

余额充值