数据结构系列（单向链表）

最新推荐文章于 2024-11-04 13:52:23 发布
最新推荐文章于 2024-11-04 13:52:23 发布
阅读量71 收藏 3
点赞数 6
分类专栏： 数据结构系列 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74051459/article/details/131901011
版权
本文介绍了单向链表的概念，对比了它相对于顺序表的优点，如空间利用率高和插入删除操作高效。并提供了C语言的具体代码实现，包括头插、尾插、头删、尾删、遍历打印、查找和插入、删除功能。
摘要由CSDN通过智能技术生成

单向链表

什么是单向链表？

链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。
而单向链表的指针只指向下一个节点，如图
在这里插入图片描述

单向链表相对于顺序表的优点

笔者写过一篇关于顺序表的文章说过顺序表的缺点
不知道的读者可以点击此处查看
相对于顺序表有以下优点

  • 不会造成空间浪费
  • 可以在节点删除插入，不需要挪动数据，只要更改指针

具体代码实现

单向链表功能

  • 头插
  • 头删
  • 在指针为pos的位置前插入
  • 尾插
  • 尾删
  • 删除指针为pos的位置
  • 遍历打印链表
  • 查找

具体代码

创建一个节点

SLN* buy_SLN()
{
	SLN* tmp = (SLN*)malloc(sizeof(SLN));
	if (tmp == NULL)
	{
		perror("malloc fail");
	}
	tmp->next = NULL;
	return tmp;
}

头插 

void pushfront(SLN** s1, NodeData x)
{
	assert(s1);
	SLN* tmp = buy_SLN();//获取空间
	tmp->a = x;
	tmp->next = *s1;
	*s1 = tmp;
}

如图
在这里插入图片描述

尾插 

void pushback(SLN** s1, NodeData x)
{
	assert(s1);
	SLN* tmp = buy_SLN();
	if (*s1 == NULL)//空链表情况
	{
		tmp->a = x;
		tmp->next = NULL;
		*s1 = tmp;
	}
	else//非空链表情况
	{
		SLN* cut = *s1;
		while (cut->next != NULL)
		{
			cut = cut->next;
		}
		tmp->a = x;
		tmp->next = NULL;
		cut->next = tmp;
	}
}

分为两种情况，空链表情况单独处理
如图
在这里插入图片描述

头删 

void popfront(SLN** s1)
{
	assert(s1);
	assert(*s1);
	SLN* tmp = *s1;
	*s1 = tmp->next;
	free(tmp);
	tmp = NULL;
}

在这里插入图片描述
注意断言！此处对*s1断言，保证链表不为空，有东西可删，下面的尾删同理

尾删 

void popback(SLN** s1)
{
	assert(*s1);
	SLN* tmp = *s1;
	if ((*s1)->next == NULL)
	{
		free(*s1);
		*s1 = NULL;
	}
	else
	{
		while (tmp->next->next != NULL)
		{
			tmp = tmp->next;
		}
		free(tmp->next);
		tmp->next = NULL;
	}
}

分两种情况，链表只有一个数据，和有两个及以上
只有一个数据，直接将数据释放，将链表置空
在这里插入图片描述

遍历打印链表

void SLNprinf(SLN* s1)
{
	assert(s1);
	SLN* p = s1;
	while (p)//最后一个为空
	{
		printf("%d->", p->a);
		p = p->next;
	}
	printf("\n");
}

查找某数据

SLN* STFind(SLN* s1, NodeData x)
{
	SLN* tmp = s1;
	while (tmp)
	{
		if (tmp->a == x)
		{
			return tmp;
		}
		tmp = tmp->next;//去下一个节点
	}
	return NULL;
}

这里返找到数据的地址

在指针为pos的位置前插入

void SLInsert(SLN** s1, SLN* pos, NodeData x)
{
	assert(s1);
	assert(pos);
	SLN* cur = *s1;
	SLN* tmp = buy_SLN();
	tmp->a = x;
	if (*s1==pos)
	{
		pushfront(s1, x);
	}
	else
	{
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		tmp->next = cur->next;
		cur->next = tmp;
	}
}

如果插入位置是链表的第一个位置则直接调用头插函数
其他位置，如图
在这里插入图片描述

删除指针为pos的位置

void SLErase(SLN** s1, SLN* pos)
{
	assert(s1);
	assert(pos);
	SLN* tmp = *s1;
	if (*s1 == pos)
	{
		popfront(s1);
	}
	else
	{
		while (tmp->next!=pos)
		{
			tmp = tmp->next;
		}
		tmp->next = pos->next;
		free(pos);
	}
}

如果只有一个数据则调用头删
其他情况如图
在这里插入图片描述
以下是完整代码以及测试

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int  NodeData;
typedef struct SListNode
{
	NodeData a;
	struct SListNode* next;
}SLN;

SLN* buy_SLN();
void pushback(SLN** s1, NodeData x);//尾插
void pushfront(SLN** s1, NodeData x);//头插
void SLNprinf(SLN* s1);//打印
void popfront(SLN** s1);//头删
void popback(SLN** s1);//尾删
SLN* STFind(SLN* s1, NodeData x);//查找
void SLInsert(SLN**s1, SLN* pos, NodeData x);//在地址为pos前位置添加
void SLInsertAfte(SLN* pos, NodeData x);//在地址为pos后的位置添加
void SLErase(SLN** s1, SLN* pos);//删除pos位置
void SLEraseAfter(SLN* pos);//删除pos后的位置
#include"lianbiao.h"
SLN* buy_SLN()
{
	SLN* tmp = (SLN*)malloc(sizeof(SLN));
	if (tmp == NULL)
	{
		perror("malloc fail");
	}
	tmp->next = NULL;
	return tmp;
}
void pushback(SLN** s1, NodeData x)
{
	assert(s1);
	SLN* tmp = buy_SLN();
	if (*s1 == NULL)//空链表情况
	{
		tmp->a = x;
		tmp->next = NULL;
		*s1 = tmp;
	}
	else//非空链表情况
	{
		SLN* cut = *s1;
		while (cut->next != NULL)
		{
			cut = cut->next;
		}
		tmp->a = x;
		tmp->next = NULL;
		cut->next = tmp;
	}
}
void pushfront(SLN** s1, NodeData x)
{
	assert(s1);
	SLN* tmp = buy_SLN();//获取空间
	tmp->a = x;
	tmp->next = *s1;
	*s1 = tmp;
}

void SLNprinf(SLN* s1)
{
	assert(s1);
	SLN* p = s1;
	while (p)
	{
		printf("%d->", p->a);
		p = p->next;
	}
	printf("\n");
}

void popfront(SLN** s1)
{
	assert(s1);
	assert(*s1);
	SLN* tmp = *s1;
	*s1 = tmp->next;
	free(tmp);
	tmp = NULL;
}
void popback(SLN** s1)
{
	assert(*s1);
	SLN* tmp = *s1;
	if ((*s1)->next == NULL)
	{
		free(*s1);
		*s1 = NULL;
	}
	else
	{
		while (tmp->next->next != NULL)
		{
			tmp = tmp->next;
		}
		free(tmp->next);
		tmp->next = NULL;
	}
}

SLN* STFind(SLN* s1, NodeData x)
{
	SLN* tmp = s1;
	while (tmp)
	{
		if (tmp->a == x)
		{
			return tmp;
		}
		tmp = tmp->next;
	}
	return NULL;
}

void SLInsert(SLN** s1, SLN* pos, NodeData x)
{
	assert(s1);
	assert(pos);
	SLN* cur = *s1;
	SLN* tmp = buy_SLN();
	tmp->a = x;
	if (*s1==pos)
	{
		pushfront(s1, x);
	}
	else
	{
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		tmp->next = cur->next;
		cur->next = tmp;
	}
}

void SLInsertAfte(SLN* pos, NodeData x)
{
	assert(pos);
	SLN* cur=pos;
	SLN* tmp = buy_SLN();
	tmp->a = x;
	tmp->next = cur->next;
	cur->next = tmp;
}

void SLErase(SLN** s1, SLN* pos)
{
	assert(s1);
	assert(pos);
	SLN* tmp = *s1;
	if (*s1 == pos)
	{
		popfront(s1);
	}
	else
	{
		while (tmp->next!=pos)
		{
			tmp = tmp->next;
		}
		tmp->next = pos->next;
		free(pos);
	}
}
void SLEraseAfter(SLN* pos)
{
    assert(pos);
	assert(pos->next);
	SLN* tmp = pos->next;
	pos->next = tmp->next;
	free(tmp);
}
#include"lianbiao.h"

int main()
{
	SLN* phead = NULL;
	pushback(&phead, 7);
	pushback(&phead, 1);
	pushback(&phead, 1);
	SLNprinf(phead);
	pushfront(&phead, 5);
	pushfront(&phead, 2);
	pushfront(&phead, 2);
	SLNprinf(phead);
	popfront(&phead);
	popback(&phead);
	popback(&phead);
	SLNprinf(phead);
    SLN*tmp=STFind(phead,5);
	printf("%d\n", tmp->a);
	SLInsert(&phead, tmp, 9);
	printf("%d\n", tmp->a);
	SLNprinf(phead);
	SLInsertAfte(tmp, 8);
	SLNprinf(phead);
	SLErase(&phead, tmp);
	SLNprinf(phead);
	SLN* tm = STFind(phead, 9);
	SLEraseAfter(tm);
	SLNprinf(phead);
}

在这里插入图片描述
单向链表的分享到这里就结束嘞！
希望大家多多三连，若有错误之处，还请不吝赐教！

不爱热闹：
关注
专栏目录
c++数据结构—单向链表
qq_67972375的博客
03-14 1908
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
数据结构之单向循环链表
jiangbazi的博客
09-05 3468
概述 单向循环链表里面的每一个节点的next都要有指向，最后一个节点的next指向head节点 单向循环链表跟普通的单链表的操作逻辑几乎—模一样，唯一的区别，结尾的判断，区别如下 建议学完单向非循环链表，再来对比 （本人先是在掘金上编辑的，然后复制粘贴自己的博客，所以图片都有掘金的水印，欢迎来我的掘金博客查看原文） 示例代码 //单向循环链表 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> typ
数据结构——单向链表
脑壳有点痒，好像要长脑子了！
08-04 1235
链表（Linked List）是一种常见的数据结构，它属于线性表的一种链式存储结构，其逻辑上相邻的元素在物理存储位置并不相邻。它由一系列节点（Node）组成，每个节点包含数据部分和指向列表中下一个节点（或者上一个节点）的指针（链接）。链表中的节点通过指针相互连接，从而形成一个序列。链表可以分为几种不同的类型，但最常见的是单向链表和双向链表。
【数据结构】单向链表
m0_73648729的博客
05-05 1248
哈喽，大家好，今天我们学习的是数据结构里的链表，这里主要讲的是不带哨兵卫头节点的单向链表，下篇将会继续带大家学习双向链表。
数据结构-单向循环链表
没出过地球
06-11 2248
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
数据结构—单向链表（详解）
热门推荐
梅山
03-16 1万+
基于C语言的链表基础，包括概念，链表的初始化，插入，删除，查找等操作。
数据结构——单向链表（C语言实现）
2402_82711634的博客
01-18 1846
无头链表：以结点为开头的链式结构——————同时也是非循环链表typedef struct SListNode//定义的是结点的结构//存放数据//存放下一个位置的地址}SLTNode;//pos就是节点的指针。
数据结构-单向链表(C语言)
m0_49408252的博客
07-22 1881
snode_t;为使链表具有通用性，在节点中只定义指针部分，数据部分通过自定义结构体的方式定义。char* name;node使得my_data_t可作为节点链接在链表中，my_data_t中数据可随实际情况改变。} slist_t;单向链表中定义head和tail分别指向链表的头和尾。
数据结构：单向链表
2303_82176667的博客
07-15 2104
(2)访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找第一个结点和最后一个结点所花费的时间不等。每读入一个数据元素则申请一个新结点，将新结点插入到尾结点后，指向新结点。(1)结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。3、插入新结点：①新结点的指针域指向结点a;1.从一个空表L开始，将新结点逐个插入到链表的尾部，尾指针指向链表的尾结点。3.从最后一个结点开始，依次将各结点插入到链表的前端。2.生成新结点，将读入数据存放到新结点的数据域中。
【数据结构】单向链表的练习题
m0_73067372的博客
02-11 1918
此题使用快慢指针，定义两 个指针：一个fast指针，一个slow指针。fast指针和slow指针是同时出发的，fast指针走两步，slow指针走一步。fast是slow的两倍，当fast指针走到链表的结尾时，slow指针走到链表的中间。❌❌❌这里很多人会想到将，链表当中的数值放到数组当中，将数组逆置，这种思路是掩耳盗铃，我们要的是将链表本身逆置一下，而不是将链表当中的数据进行反转。使用快慢指针来解这个问题，让快指针先走两步，慢指针走一步，最后两个指针若能相遇，则链表当中有环。当然上图考虑的情况还不全，
基于数据结构的单向链表排序算法探究.pdf
08-07
#资源达人分享计划#
数据结构-单向链表教程.zip
08-24
本系列教程深入剖析链表数据结构，从基础概念到高级操作，全面覆盖。首先介绍链表的提出背景，随后通过单链表的ADT（抽象数据类型）模型，阐释其理论基础。接着，通过实际代码演示单链表及结点的定义，以及如何实现...
python数据结构链表之单向链表(实例讲解)
01-21
单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem...
C++ 数据结构 静态顺序表、动态顺序表。
qq_50373827的博客
11-01 679
静态顺序表（Static Array List）是一种线性数据结构，通常用数组实现。它具有固定的大小，并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。
探索数据结构：数组与链表
最新发布
qq_36287830的博客
11-04 438
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
线性数据结构之数组
m0_61840987的博客
10-31 393
数组是一种数据结构，用于存储多个相同类型的元素。在许多编程语言中，数组是最基本的数据结构之一，常用于管理和处理数据。数组的元素在内存中是连续存储的，可以通过索引直接访问。
数据结构————map,set详解
2301_79083481的博客
10-29 1094
详解map,set
数据结构模拟题［五］
mufengzhiyu666的博客
11-01 971
8．设连通图 G 中的边集 E={(a ，b)，(a，e)，(a，c)，(b， e)， (e， d)，(d，f) ，(f， c)}，则从顶点 a 出发可。4. 设散列表的长度为 8，散列函数 H(k)=k mod 7，初始记录关键字序列为 (25 ，31，8，27，13，68) ，要。3．设一组初始记录关键字序列为 (25，50，15， 35，80，85，20，40，36，70)，其中含有 5 个长度为 2 的。4．函数 substr( “DATASTRUCTURE”， 5，9) 的返回值为（ ）。
C语言实现单向链表动态数据结构
"本资源主要介绍了如何在C语言中...总结来说，这个资源提供了C语言实现单向链表的基础知识，包括链表节点的定义、链表的创建方法以及如何通过函数来构建链表，对于学习数据结构和C语言编程的初学者来说是非常有价值的。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值