数据结构之单链表详解（C语言手撕）

news2024/12/25 0:44:55

​
在这里插入图片描述

🎉个人名片：

🐼作者简介：一名乐于分享在学习道路上收获的大二在校生
🙈个人主页🎉：GOTXX
🐼个人WeChat：ILXOXVJE
🐼本文由GOTXX原创，首发CSDN🎉🎉🎉
🐵系列专栏：零基础学习C语言----- 数据结构的学习之路----C++的学习之路
🐓每日一句：如果没有特别幸运，那就请特别努力！🎉🎉🎉
——————————————————————————————————————————————

🎉文章简介：

🎉本篇文章对      用C语言实现单链表   学习的相关知识进行分享！🎉💕
如果您觉得文章不错，期待你的一键三连哦，你的鼓励是我创作动力的源泉，让我们一起加油，一起奔跑，让我们顶峰相见！！！🎉🎉🎉
————————————————

一.链表的概念及结构

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

在这里插入图片描述从图片中可以看出，链表的每个节点都是一个结构体，该结构体中有一个存储数据的变量和一个指向下一节点的结构体指针；
在逻辑上是连续的，但是在物理空间上不一定连续，因为链表节点都是每次插入数据时在堆上申请出来的；每次申请出来的空间不一定是连续的；

二.无头单向非循环链表的结构

在这里插入图片描述无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
构的子结构，如哈希桶、图的邻接表等等；

二.无头单向非循环链表的结构及实现

一.结构：

在这里插入图片描述

二.功能函数的实现（含性能分析与图解）
  1. 打印链表
  2. 创建节点函数
  3. 头插节点函数
  4. 头删节点函数
  5. 尾插节点函数
  6. 尾删节点函数
  7. 查找函数
  8. 在一节点位置之前插入一个节点
  9. 在一节点位置之后插入一个节点
  10. 在一节点位置之前删除一个节点
  11. 在一节点位置之后删除一个节点
打印链表

图解：遍历访问
在这里插入图片描述先定义一个结点指针指向头节点，往后依次遍历，与数组不同的是，不是cur++，而是让cur指向下一个节点，即cur=cur->next;

代码实现：

void SLPrint(SLNode* pphead)
{
	assert(pphead);     //断言

	SLNode* cur = pphead;     //让cur指向头节点进行遍历
	while (cur)        //注意：条件不是cur->next，因为如果是cur->next为空就不进入循环的话，则最后一个节点就访问不到
	{
		printf("%d ", cur->val);
		cur = cur->next;
	}
	printf("NULL");    //最后打印一个NULL、方便观察
	printf("\n");
}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

创建节点函数

代码实现：

SLNode* BuySLnewnode(SLDateType x)
{

	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));   //注意：创建的是节点，一个结构体，而不是一个数据类型
	if (newnode == NULL)          //判断
	{
		perror("malloc fail");
		exit(-1);             //开辟失败，以异常退出程序
	}
	newnode->next = NULL;     //下一个节点置NULL
	newnode->val = x;         //赋值

	return newnode;           //返回该该结点指针
}
头插节函数

图解：
在这里插入图片描述

代码实现：

void SLPushFront(SLNode** pphead, SLDateType x)   
//注意：这里需要节点的二级指针，因为外面调用的时候，如果传的是头指针的话，是传值，
//函数里面改变不影响头指针的指向，所以这里需要二级指针，函数调用的时候需要传二级指针
{

	SLNode* newnode = BuySLnewnode(x);     //创建新节点
	if (*pphead == NULL)       //检查，如果为空链表
	{
		*pphead = newnode;      //直接将*pphead指向新节点
	}
	else
	{
		newnode->next = *pphead;    //第二种情况
		(*pphead) = newnode;
	}

}

性能分析：
时间复杂度：O(1)
空间复杂度：O（1）

头删节点函数

图解：
在这里插入图片描述

代码实现：

void SLPopFront(SLNode** pphead)
{
	assert(*pphead);    //头指针不能为空

	if((*pphead)->next==NULL)     //第一种情况
	{
		free(*pphead);     
		*pphead = NULL;

		return;
	}
	SLNode* tmp = (*pphead)->next;   //保存下一个节点
	free(*pphead);
	*pphead = tmp;

}

性能分析：
时间复杂度：O(1)
空间复杂度：O(1)

尾插节点函数

图解：
在这里插入图片描述

代码实现：

void SLPushBack(SLNode** pphead, SLDateType x)
{

	SLNode* newnode = BuySLnewnode(x);
	if (*pphead == NULL)     //空链表
	{ 
		*pphead = newnode;
		return;
	}

	SLNode* tail = *pphead;     //定义一个尾指针
	while (tail->next)
	{
		tail = tail->next;
	}                           //退出循环后tail->next为NULL；
	tail->next = newnode;       //链接

}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

尾删节点函数

图解：
在这里插入图片描述

代码实现：

在这里插入代码片void SLPopBack(SLNode** pphead)
{
	assert(*pphead);

	if ((*pphead)->next == NULL)   //第一种情况
	{
		free(*pphead);
		*pphead = NULL;

		return;
	}

	SLNode* Prevtail = *pphead;    //记录尾指针前面的一个节点
	SLNode* tail = *pphead;        //尾指针
	while (tail->next)
	{
		Prevtail = tail;           
		tail = tail->next;
	}
	free(tail);             //释放掉尾节点
	Prevtail->next = NULL;   

}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

查找函数

代码实现：

SLNode* SLFind(SLNode* pphead, SLDateType x)
{
	assert(pphead);

	SLNode* cur = pphead;       //遍历查找
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;      //返回节点指针
		} 
		cur = cur->next;
	}

	return NULL;         //没找到，返回NULL
}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

在pos位置之前插入一个节点

图解：
在这里插入图片描述

代码实现：

//在pos之前插入
void SLInsert(SLNode** pphead, SLNode* pos, SLDateType x)
{
	assert(*pphead);
	assert(pos);

	if (pos == *pphead)        //第一种情况：头插
	{
		SLPushFront(pphead, x);
		  
		return;
	}
	SLNode* newnode = BuySLnewnode(x);     
	
	SLNode* cur = *pphead;     //遍历，找到pos的前一个节点
	while (cur->next)
	{
		if (cur->next == pos)      //找到了
		{
			newnode->next = cur->next;    //链接
			cur->next = newnode;

			return;
		}
		cur = cur->next;
	}

}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

在pos位置之后插入一个节点

图解：
在这里插入图片描述

代码实现：

//在pos之后插入
void SLInsertBack(SLNode* pos, SLDateType x)
{
	assert(pos);
	SLNode * newnode = BuySLnewnode(x);     

	newnode->next = pos->next;   //链接
	pos->next = newnode;

}

性能分析：

删除pos位置之前一个节点

图解：
在这里插入图片描述

代码实现：

//删除pos之前的节点
void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(pos);
	assert(pos != *pphead);
	if (pos== (*pphead)->next)  //头删，第一种情况
	{
		free(*pphead);
		(*pphead) = pos;

		return;
	}
	SLNode* cur = *pphead;
	while (cur)
	{
		if (cur->next->next == pos)   //找到pos前面的第二个节点
		{
			free(cur->next);
			cur->next = pos;     //链接

			return;
		}
		cur = cur->next;
	}

}

性能分析：
时间复杂度：O(N)
空间复杂度：O(1)

删除pos位置之后一个节点

图解：
在这里插入图片描述

代码实现：

//删除pos之后的节点
void SLEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);   //当pos后无节点，无意义

	if (pos->next->next == NULL)   //尾删
	{
		pos->next = NULL;
		return;
	}
	SLNode* cur = pos->next->next;   
	free(pos->next);   
	pos->next = cur;   //链接
	cur = NULL;

}

性能分析：
时间复杂度：O(1)
空间复杂度：O(1)

二.总代码

```cpp
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDateType;

typedef struct SListNode
{
	SLDateType val;
	struct SListNode* next;
}SLNode;

SLNode* BuySLnewnode(SLDateType x);
void SLPrint(SLNode* pphead);

void SLPushBack(SLNode** pphead, SLDateType x);
void SLPushFront(SLNode** pphead, SLDateType x);

void SLPopFront(SLNode** pphead); 
void SLPopBack(SLNode** pphead);

SLNode* SLFind(SLNode* pphead,SLDateType x);

//在pos之前插入
void SLInsert(SLNode** pphead, SLNode* pos,SLDateType x);

//在pos之后插入
void SLInsertBack(SLNode* pos, SLDateType x);

//删除pos之后的节点
void SLEraseBack(SLNode* pos);

//删除pos之前的节点
void SLErase(SLNode** pphead,SLNode* pos);



```cpp
#include"SList.h"


SLNode* BuySLnewnode(SLDateType x)
{

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

	return newnode;
}

void SLPrint(SLNode* pphead)
{
	assert(pphead);

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

void SLPushFront(SLNode** pphead, SLDateType x)
{

	SLNode* newnode = BuySLnewnode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		newnode->next = *pphead;
		(*pphead) = newnode;
	}

}
void SLPushBack(SLNode** pphead, SLDateType x)
{

	SLNode* newnode = BuySLnewnode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}

	SLNode* tail = *pphead;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next = newnode;

}

void SLPopFront(SLNode** pphead)
{
	assert(*pphead);

	if((*pphead)->next==NULL)
	{
		free(*pphead);
		*pphead = NULL;

		return;
	}
	SLNode* tmp = (*pphead)->next;
	free(*pphead);
	*pphead = tmp;

}
void SLPopBack(SLNode** pphead)
{
	assert(*pphead);

	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;

		return;
	}

	SLNode* Prevtail = *pphead;
	SLNode* tail = *pphead;
	while (tail->next)
	{
		Prevtail = tail;
		tail = tail->next;
	}
	free(tail);
	Prevtail->next = NULL;

}
SLNode* SLFind(SLNode* pphead, SLDateType x)
{
	assert(pphead);

	SLNode* cur = pphead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}


//在pos之前插入
void SLInsert(SLNode** pphead, SLNode* pos, SLDateType x)
{
	assert(*pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SLPushFront(pphead, x);

		return;
	}
	SLNode* newnode = BuySLnewnode(x);
	
	SLNode* cur = *pphead;
	while (cur->next)
	{
		if (cur->next == pos)
		{
			newnode->next = cur->next;
			cur->next = newnode;

			return;
		}
		cur = cur->next;
	}

}

//在pos之后插入
void SLInsertBack(SLNode* pos, SLDateType x)
{
	assert(pos);
	SLNode * newnode = BuySLnewnode(x);

	newnode->next = pos->next;
	pos->next = newnode;

}


//删除pos之后的节点
void SLEraseBack(SLNode* pos)
{
	assert(pos);
	assert(pos->next);

	if (pos->next->next == NULL)
	{
		pos->next = NULL;
		return;
	}
	SLNode* cur = pos->next->next;
	free(pos->next);
	pos->next = cur;
	cur = NULL;

}

//删除pos之前的节点
void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(pos);
	assert(pos != *pphead);
	if (pos== (*pphead)->next)
	{
		free(*pphead);
		(*pphead) = pos;

		return;
	}
	SLNode* cur = *pphead;
	while (cur)
	{
		if (cur->next->next == pos)
		{
			free(cur->next);
			cur->next = pos;

			return;
		}
		cur = cur->next;
	}

}
三.性能分析

与顺序表相比：
优点：
1.按需申请，没有空间浪费；
2.头插头删效率高

缺点：
1.不支持下标随机访问
2.尾插尾删效率低

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1499870.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

（五）关系数据库标准语言SQL

（五）关系数据库标准语言SQL

注&#xff1a;课堂讲义使用的数据库 5.1利用SQL语言建立数据库 5.1.1 create Database 5.1.2 create schema...authorization... 创建数据库和创建模式的区别&#xff1a; 数据库是架构的集合&#xff0c;架构是表的集合。但在MySQL中&#xff0c;他们使用的方式是相同的。 …
阅读更多...
如何修改SAP标准代码

如何修改SAP标准代码

文章目录 1 Introduction2 Method2.1 Click Change2.2 Switch off Assistent 3 Summary 1 Introduction In the sap sometimes we need change the standard code . I.E. How to comment code ? 2 Method 2.1 Click Change 2.2 Switch off Assistent This is the result wh…
阅读更多...
GAMMA电源维修高压直流电源ES30P-5W ES系列

GAMMA电源维修高压直流电源ES30P-5W ES系列

美国Gamma高压电源维修型号&#xff1a;D-ES30R-10N-5W/M&#xff0c;LXR30-1N&#xff0c;XRM5N-100W&#xff0c;ES50P-10W/DDPM&#xff0c;ES60P-10W/DDPM&#xff0c;RR20-20P/DDPM&#xff0c;ES30P-10W&#xff0c;ES60P-10W DDPM&#xff0c;RR60-18P/220V&#xff0c;…
阅读更多...
iStoreOS系统内安装HomeAssistant服务

iStoreOS系统内安装HomeAssistant服务

iStoreOS系统内安装HomeAssistant服务 1. HomeAssistant服务 HomeAssistant是一款基于Python的开源智能家居系统&#xff0c;简称HA。 HomeAssistant可以方便地连接各种外部设备&#xff0c;如智能设备、摄像头、邮件、短消息和云服务等&#xff0c;其成熟的可连接组件有近千…
阅读更多...
rocketmq学习笔记（一）安装部署

rocketmq学习笔记（一）安装部署

初次使用rocketmq&#xff0c;记录一下全流程步骤。 1、下载安装包 首先在官网&#xff0c;下载安装包&#xff0c;可也根据官方文档进行部署&#xff0c;但有一些细节没说明&#xff0c;可能会有坑&#xff0c;本文会尽量详细的描述每个步骤&#xff0c;把我踩过的坑填补上。…
阅读更多...
Python自动化测试：API接口自动化——requests、webSocket

Python自动化测试：API接口自动化——requests、webSocket

接口自动化测试1 一、requests二、简单示例1.导入/引入库2.请求与响应示例1>简单访问百度主页-GET请求2>简单的登录请求-POST请求3>保存cookies至头信息headers4>其他接口请求时携带headers 三、webSocketwebSocket连接与数据收发示例 本文介绍了借助Python的reque…
阅读更多...
Manacher 算法——Leetcode 5.最长回文子串

Manacher 算法——Leetcode 5.最长回文子串

在了解之前&#xff0c;我们先要了解什么是回文串&#xff0c;什么是回文子串。 回文串和回文子串&#xff1a; 回文串是指一个字符串正序遍历和反向遍历结果相同的字符串。如 ABBA&#xff0c;正着读反着读结果是一样的。 有了回文串的概念&#xff0c;回文子串的概念也就显…
阅读更多...
顺势交易中，用什么方法识别趋势的开始与结束?

顺势交易中，用什么方法识别趋势的开始与结束?

在交易过程中&#xff0c;大家都知道顺势交易的重要性&#xff0c;但如何对趋势的开始和结束进行量化判断呢&#xff1f; 趋势交易需要一个正确的出发点和思想方向。也就是说&#xff0c;趋势交易需要关注什么呢&#xff1f;有哪些相关的技术手段可以利用呢&#xff1f; 首先&a…
阅读更多...
springboot使用异步多线程

springboot使用异步多线程

shigen坚持更新文章的博客写手&#xff0c;擅长Java、python、vue、shell等编程语言和各种应用程序、脚本的开发。记录成长&#xff0c;分享认知&#xff0c;留住感动。 个人IP&#xff1a;shigen 在shigen之前的很多文章中&#xff0c;提到了线程池&#xff1a; 高性能API设计…
阅读更多...
一 windso10 笔记本刷linux cent os7.9系统

一 windso10 笔记本刷linux cent os7.9系统

1:准备材料 16G以上U盘, 笔记本一台 镜像选了阿里云镜像:centos-7-isos-x86_64安装包下载_开源镜像站-阿里云 软件:链接&#xff1a;https://pan.baidu.com/s/13WDp2bBU1Pdx4gRDfmBetg 提取码&#xff1a;09s3 2:把镜像写入U盘,本人已经写入好了,选择镜像,点开始就是,确定等…
阅读更多...
javascript正则深入

javascript正则深入

文章目录 一、前言二、高级`API`2.1、模式匹配的用法`(x)`2.2、非捕获括号的模式匹配`(?:x)`2.3、先行断言`x(?=y)`2.4、后行断言`(?<=y)x`2.5、正向否定查找`x(?!y)`2.6、反向否定查找`(?<!y)x`2.7、字符集合和反向字符集合的用法 `[xyz] / [^xyz]`2.8、词边界和非…
阅读更多...
开关电源安规测试标准与测试要求

开关电源安规测试标准与测试要求

安规测试是对开关电源进行电气性能、安全性能等检测&#xff0c;确保开关电源符合规定并且安全可靠&#xff0c;为开关电源的质量把关。那么开关电源安规测试有哪些测试要求和标准呢&#xff1f; 开关电源安规测试要求 一、测试前 1. 首先&#xff0c;要检查测试环境&#xff0…
阅读更多...
电子商务平台中商品数据采集|API数据接口采集商品的高效性体现

电子商务平台中商品数据采集|API数据接口采集商品的高效性体现

电子商务平台由一个个产品所构成,通过对产品的分析可以有效发掘用户需求,优化店铺产品结构,提升客户粘性、客单价、销售利润等。 一、产品行业数据采集API接口 采集产品行业数据的核心目的是了解该产品的市场需求变化情况,常用到的数据采集指标包括产品搜索指数和产品交易指数两…
阅读更多...
项目建设计划书-word

项目建设计划书-word

【项目建设计划书-word】 项目描述&#xff08;项目目标&#xff0c;客户需求情况&#xff0c;项目交付清单&#xff0c;验收标准和交付期限&#xff0c;服务及约束&#xff09;项目组织&#xff08;项目组人员架构&#xff0c;职责分工&#xff0c;人员投入安排及时间点安排&…
阅读更多...
Python爬虫——Scrapy-1

Python爬虫——Scrapy-1

目录 简介 安装 基本使用 1. 创建爬虫的项目 2. 创建爬虫文件 3. 运行爬虫代码 scrapy项目组成 scrapy工作原理 ​编辑 58同城 scrapy架构组成 汽车之家 总结 简介 Scrapy 是一个基于 Python 的开源网络爬虫框架&#xff0c;它可以帮助开发者快速、高效地构…
阅读更多...
MySQL和语言的连接

MySQL和语言的连接

1.下载开发包 有了之前的基础&#xff0c;就可以使用语言来使用数据库了&#xff0c;实际上原生命令行操作数据库的场景比较少&#xff0c;语言级别的库和包才更加常用&#xff0c;接下我来带您学习如何使用 C/C 访问 MySQL 客户端。 然后创建一个可以远程登录的用户&#xf…
阅读更多...
Transformer中的FlashAttention

Transformer中的FlashAttention

FlashAttention是一种用于Transformer模型的近似注意力机制&#xff0c;旨在减少注意力计算和内存需求。引入FlashAttention是因为传统Transformer模型中的自注意力机制在处理长序列时存在时间和存储复杂度上的挑战&#xff0c;需要大量的计算资源和内存来处理更长的上下文背景…
阅读更多...
【数据结构】二、线性表：6.顺序表和链表的对比不同（从数据结构三要素讨论：逻辑结构、物理结构（存储结构）、数据运算（基本操作））

【数据结构】二、线性表：6.顺序表和链表的对比不同（从数据结构三要素讨论：逻辑结构、物理结构（存储结构）、数据运算（基本操作））

文章目录 6.对比&#xff1a;顺序表&链表6.1逻辑结构6.2物理结构&#xff08;存储结构&#xff09;6.2.1顺序表6.2.2链表 6.3数据运算&#xff08;基本操作&#xff09;6.3.1初始化6.3.2销毁表6.3.3插入、删除6.3.4查找 6.对比&#xff1a;顺序表&链表 6.1逻辑结构 顺…
阅读更多...
禁闭室的乐趣

禁闭室的乐趣

解法&#xff1a; 暴力 #include<iostream> #include<vector> #include<algorithm> using namespace std; #define endl \n bool cmp(string& a, string& b) {if (a.size() ! b.size())return a.size() > b.size(); } int main() {ios::sync_wi…
阅读更多...
【李沐精读系列】GPT、GPT-2和GPT-3论文精读

【李沐精读系列】GPT、GPT-2和GPT-3论文精读

论文&#xff1a; GPT&#xff1a;Improving Language Understanding by Generative Pre-Training GTP-2&#xff1a;Language Models are Unsupervised Multitask Learners GPT-3&#xff1a;Language Models are Few-Shot Learners 参考&#xff1a;GPT、GPT-2、GPT-3论文精读…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023