探索数据结构：单链表的实践和应用

最新推荐文章于 2024-06-14 10:22:04 发布
最新推荐文章于 2024-06-14 10:22:04 发布
阅读量2k 收藏 10
点赞数 81
分类专栏： 渐入佳境之数据结构和算法 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x3262551980/article/details/137891052
版权

🔑🔑博客主页：阿客不是客

🍓🍓系列专栏：渐入佳境之数据结构与算法

欢迎来到泊舟小课堂

😘博客制作不易欢迎各位👍点赞+⭐收藏+➕关注

​

 一、前言

前面我们学习了数据结构中的顺序表，知道了顺序表的空间是连续存储的，这与数组非常类似，为我们随机访问数据提供了便利的条件，但顺序表也有着一些不足之处：

  1. 尾部插入删除效率还不错，中部或者头部插入删除需要挪动数据，效率低下。
  2. 顺序表满了以后需要扩容，扩容本身也有一定的消耗。
  3. 扩容存在空间浪费：一次扩的多了容易造成浪费，一次扩的少了可能要频繁扩容。

这些大大增加我们的时间与空间成本。为了解决这个问题，就要学习我们今天要讲解的链表。

二、什么是链表

2.1 链表的概念

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

链表是由一个个结点组成的，结点如下图所示：

注意：链表中的最后一个结点的next指向空，next=NULL，一个个结点串成了链表：

2.2 链表的分类

链表的种类多种多样，它们大致可以分为三类：

2.2.1 单向或双向

2.2.2 带不带头结点

2.2.3 循环不循环

三、单链表的基本操作

单链表的基本操作包括单链表的初始化、判断空链表、销毁、清空以及求表长这些较为简单的操作，还有更为重要的单链表的取值、按值查找返回元素所在地址、按值查找返回元素所对应序号、结点插入和删除以及头插法和尾插法建立单链表。目前只实现了这些操作，并进行的测试。

3.1 单链表的初始化

单链表的结点定义方式与我们以往定义的方式都不同，它是一个结构体中包含两个成员。一个是存储数值，一个存放下一个结点的地址。

typedef int SLTDataType;

typedef  struct SList
{
	SLTDataType val;
	struct SList* next;//下一个结点的地址
}SLT;

3.2 创建一个新结点

后面我们要在单链表中进行头插和尾插，此时插入的不再是像顺序表一样简单的SLDateType数据了，而是一个结点，这个结点是包括SLTDateType数据以及SLTDateType*的指针，因此，为了方便和减少代码的重复度，我们另写一个函数用来专门创建新结点。

SLT* CreateNode(SLTDataType x)
{
	SLT* newnode = (SLT*)malloc(sizeof(SLT));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	//原本指向下一个结点的指针放在插入的结点的里面
	//尾插是newnode->next = NULL
	//尾插中经过while循环，tail->next == NULL
	newnode->next = NULL;
	return newnode;
}

3.3 打印单链表

注意：链表和顺序不同的是，顺序表传过来的指针是肯定不会为空的，而链表传过来的指针是可能为空的，比如说当链表中没有元素时，头指针所指向的就是NULL，如果在第一行写上断言就会有问题。

void SLTPrint(SLT* phead)//初位置的指针
{
	SLT* tail = phead;//指向链表的第一个结点（结构体）
	//遍历链表
	while (tail != NULL)//尾结点的next为空，tail指向尾结点
	{
		printf("%d->", tail->val);
		tail = tail->next;
	}
	printf("NULL\n");
}

3.4 单链表尾插

注意：在创建结点时，已经让 结点.next=NULL，所以不需要在插入完结点后，再让新结点的next指针为NULL。

有人可能会有疑问，为什么之前打印链表的时候不用断言指针，而在尾插时就要断言指针，以及为什么函数的形参是二级指针，而不使用一级指针。

因为，尾插分为两种情况:

  1. 当链表为空时，头指针phead指向NULL，尾插相当于头插，此时要改变phead的指向，让phead指向这个新结点，此时就需要二级指针来改变一级指针的值（如果我们用一级指针做形参，形参的改变不会影响实参，那么一级指针phead就不会被改变）。
  2. 至于这个什么时候要断言指针，什么时候不用断言指针：
    • 一级指针也就是phead，当链表为空的时候，phead就是为NULL，phead存在为空的可能。
    • 而二级指针永远指向phead，phead的地址是永远存在的，那么pphead就一定不可能为空，所以需要断言pphead。
void SLTpushback(SLT** pphead, SLTDataType x)
{
	assert(pphead);
	SLT* newnode = CreateNode(x);//新结点的地址
 	if (*pphead == NULL)//改变结构体的指针（二级指针）
	{
		*pphead = newnode; 
	}
	else
	{
		SLT* tail = *pphead;
		while (tail->next != NULL)//tail->next,当链表为空会解引用空指针
		{
			tail = tail->next;
		}
		//下一个结构体的指针被存放在结构体成员里面
		//可以使用一级指针访问结构体的成员来间接访问下一个结构体的指针
		//第一个结点的结构体的指针没有存放，所以要用二级指针
		tail->next = newnode;//修改结构体的内容（一级指针）
	}
}

3.5 单链表头插

头插没什么好说的，记住要断言*pphead，保证链表内容不为空，头删也同理。

void SLTpushfront(SLT** pphead, SLTDataType x)
{
	assert(pphead);
	SLT* newnode = CreateNode(x);
	newnode->next  = *pphead;
	*pphead = newnode;
}

3.6 单链表尾删

要想删除链表中的元素，就必须保证原链表就有元素，因此要断言assert(*pphead)。

尾删需要分情况去讨论：

void SLTpopback(SLT** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLT* tail = *pphead;
	if (tail->next == NULL)//只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		while (tail->next->next != NULL)//tail指向的结点后面第二个不为空
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

3.7 单链表头删

void SLTpopfront(SLT** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLT* tail= *pphead;
	*pphead = tail->next;
	free(tail);
	tail = NULL;
}

3.8 单链表的查找

这个函数返回值不再是void，而是SListNode*，把找到的结点的地址返回去，这个函数一般会跟结点插入删除之类的函数一起使用。

SLT* SLTfind(SLT* phead, SLTDataType x)
{
	SLT* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

3.9 单链表任意位置插入

void SLTInsert(SLT** pphead, SLT* pos, SLTDataType x)
{
	assert(pphead);
	//pphead 是二级指针，不会为空
	//*pphead == NULL 链表为空
	//要么都为空，要么都不为空
	assert((pos && *pphead)||(!pos && !(*pphead)));

	if (*pphead == NULL)
	{
		SLTpushfront(pphead, x);
	}
	else
	{
		SLT* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		SLT* newnode = CreateNode(x);
		prve->next = newnode;
		newnode->next = pos;
	}
}

3.10 单链表任意位置删除

这里我要提醒一下，千万不要忘记判断pos是否正确，不要只单单断言pos是否为NULL，还要判断能不能在链表中找到pos这个地址。

void SLTErase(SLT** pphead, SLT* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SLTpopfront(pphead);
	}
	else
	{
		SLT* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		prve->next = pos->next;
		free(pos);
	}
}

3.11 单链表的销毁

销毁链表这一块，咱可不敢直接free(phead)，因为链表在物理结构上是不连续存储的，销毁链表必须要一个结点一个结点去销毁！！！！最后不要忘记把phead置为NULL。

void SLTDestory(SLT** pphead)
{
	assert(pphead);
	SLT* cur = *pphead;
	while (cur)
	{
		//方法一：
		//cur = cur->next;
		//free(*pphead);//释放掉了phead的空间
		//*pphead = cur;

		SLT* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

四、完整代码

4.1 SLT.h

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

typedef int SLTDataType;

typedef  struct SList
{
	int val;
	struct SList* next;//下一个结点的地址
}SLT;

void SLTPrint(SLT* phead);//打印链表

SLT* CreateNode(SLTDataType x, SLT* tail);//创建一个新结点

void SLTpushback(SLT** pphead, SLTDataType x);//尾插
void SLTpushfront(SLT** pphead, SLTDataType x);//头插
void SLTpopback(SLT** pphead);
void SLTpopfront(SLT** phead);

SLT* SLTfind(SLT* phead, SLTDataType x);

//与find函数结合使用
//在pos前面插入
void SLTInsert(SLT** pphead, SLT* pos, SLTDataType x);
//删除pos位置
void SLTErase(SLT** pphead, SLT* pos);

void SLTDestory(SLT** pphead);//销毁

4.2 SLT.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

SLT* CreateNode(SLTDataType x)
{
	SLT* newnode = (SLT*)malloc(sizeof(SLT));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	//原本指向下一个结点的指针放在插入的结点的里面
	//尾插是newnode->next = NULL
	//尾插中经过while循环，tail->next == NULL
	newnode->next = NULL;
	return newnode;
}

void SLTPrint(SLT* phead)//初位置的指针
{
	SLT* tail = phead;//指向链表的第一个结点（结构体）
	//遍历链表
	while (tail != NULL)//尾结点的next为空，tail指向尾结点
	{
		printf("%d->", tail->val);
		tail = tail->next;
	}
	printf("NULL\n");
}


void SLTpushback(SLT** pphead, SLTDataType x)
{
	assert(pphead);
	SLT* newnode = CreateNode(x);//新结点的地址
 	if (*pphead == NULL)//改变结构体的指针（二级指针）
	{
		*pphead = newnode; 
	}
	else
	{
		SLT* tail = *pphead;
		while (tail->next != NULL)//tail->next,当链表为空会解引用空指针
		{
			tail = tail->next;
		}
		//下一个结构体的指针被存放在结构体成员里面
		//可以使用一级指针访问结构体的成员来间接访问下一个结构体的指针
		//第一个结点的结构体的指针没有存放，所以要用二级指针
		tail->next = newnode;//修改结构体的内容（一级指针）
	}
}

void SLTpushfront(SLT** pphead, SLTDataType x)
{
	assert(pphead);
	SLT* newnode = CreateNode(x);
	newnode->next  = *pphead;
	*pphead = newnode;
}

void SLTpopback(SLT** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLT* tail = *pphead;
	if (tail->next == NULL)//只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		while (tail->next->next != NULL)//tail指向的结点后面第二个不为空
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

void SLTpopfront(SLT** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLT* tail= *pphead;
	*pphead = tail->next;
	free(tail);
	tail = NULL;
}

SLT* SLTfind(SLT* phead, SLTDataType x)
{
	SLT* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

void SLTInsert(SLT** pphead, SLT* pos, SLTDataType x)
{
	assert(pphead);
	//pphead 是二级指针，不会为空
	//*pphead == NULL 链表为空
	//要么都为空，要么都不为空
	assert((pos && *pphead)||(!pos && !(*pphead)));

	if (*pphead == NULL)
	{
		SLTpushfront(pphead, x);
	}
	else
	{
		SLT* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		SLT* newnode = CreateNode(x);
		prve->next = newnode;
		newnode->next = pos;
	}
}

void SLTErase(SLT** pphead, SLT* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SLTpopfront(pphead);
	}
	else
	{
		SLT* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		prve->next = pos->next;
		free(pos);
	}
}

void SLTDestory(SLT** pphead)
{
	assert(pphead);
	SLT* cur = *pphead;
	while (cur)
	{
		//方法一：
		//cur = cur->next;
		//free(*pphead);//释放掉了phead的空间
		//*pphead = cur;

		SLT* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

阿客不是客
关注
  • 81
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入探索数据结构技术：理论、实践与应用
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-16 1万+
数据结构技术的学习是一个逐步深入的过程，需要理论与实践相结合，不断通过编程练习巩固所学知识。只有扎实掌握数据结构，才能在面对复杂数据处理问题时游刃有余，为软件开发、数据分析、算法设计等领域的专业发展打下坚实基础。希望通过本文的引导，读者能够系统地学习并掌握数据结构技术，不断提升自身的编程素养与问题解决能力。
【探索数据结构】线性表之单链表
2301_80840905的博客
05-19 1482
文章重点介绍:不带头节点不循环的单链表
【探索数据结构】线性表之双链表
2301_80840905的博客
05-23 939
文章重点介绍：带头节点循环双向链表。
【C/C++ 数据结构】深入探索数据结构中算法复杂度：从C++和数学的视角
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-13 789
数据结构是计算机中存储和组织数据的方式，而算法则是解决特定问题的步骤和方法。正如《算法导论》(Introduction to Algorithms) 中所说：“算法是计算的核心，是计算机科学的灵魂。”
从零起步：学习数据结构的完整路径
学IT，找陈寒
08-21 2308
数据结构是一个广泛的领域，需要持续的学习和实践。通过深入理解不同的数据结构和算法，你将能够更有效地解决问题、提升代码效率，并在编程领域中更具竞争力。无论你是初学者还是有一定经验的开发者，始终记得这条学习路径，它将帮助你逐步掌握数据结构的精髓。🧸结尾😊🙏。
数据结构与算法 内容待加
m0_74859128的博客
03-27 91
队列和栈类似，也是一种特殊的线性表。和栈不同的是，队列只允许在表的一端进行插入操作，而在另一端进行删除操作。链表是一种数据元素按照链式存储结构进行存储的数据结构，这种存储结构具有在物理上存在非连续的特点。在图结构中，数据结点一般称为顶点，而边是顶点的有序偶对。栈是一种特殊的线性表，它只能在一个表的一个固定端进行数据结点的插入和删除操作。数组是一种聚合数据类型，它是将具有相同类型的若干变量有序地组织在一起的集合。堆是一种特殊的树形数据结构，一般讨论的堆都是二叉堆。树是典型的非线性结构，它是包括，
探索算法与数据结构的世界：让编程事半功倍
gitblog_00057的博客
05-24 234
探索算法与数据结构的世界：让编程事半功倍 项目地址:https://gitcode.com/qieguo2016/algorithm 在这个数字化的世界里，高效的数据处理和智能的算法应用至关重要。无论你是软件开发者、面试候选人还是对技术充满热情的学习者，理解并掌握数据结构与算法都是必不可少的技能。今天，我们为你带来一个开源项目——算法与数据结构，它以通俗易懂的方式教你如何理解和运用这些核心概念，并...
帮你初步了解数据结构的重点，探索数据结构:从基础到高级
weixin_74215538的博客
07-05 75
我们将讨论图的常见表示方法和遍历算法，如深度优先搜索和广度优先搜索，以及图在社交网络和路由算法中的应用，学会如何统计图的入度和出度，更深一层次的，我们要学会计算最短路径问题。我们将详细了解它们的用途和基本操作，并介绍常见的应用场景，需要掌握先序，后序，中序输入，以及一些统计和读写操作。它是由相同类型的元素按照顺序排列而成，可以通过下标快速访问指定位置的元素，但是数组存储具有预先分配空间的特性，所以容易出现空间浪费的现象。通过本文的学习，你应当对数据结构的核心概念和常见应用有了初步的了解。
数据结构课程设计
热门推荐
大虾米
07-10 2万+
目录 1. 需求分析: 4 1.1问题描述: 4 1.2问题要求: 4 2. 概要设计 4 2.1抽象数据类型定义 4 2.2设计思路 4 2.2.1模块调用： 4 3详细设计 6 3.1存储结构设计 6 3.1.1顺序查找的基本思想 6 3.1.2二分法查找（折半查找）的基本思想 7 3.1.3斐波那契查找的前提是待查找的查找表必须顺序存...
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
数据结构：拆分单链表代码
10-28
数据结构：拆分单链表代码
数据结构与算法实验（C++）：单链表实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。...数据结构与算法实验
数据结构-C语言版：单链表例题.ppt
06-06
数据结构-C语言版：单链表例题.ppt
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列，动态顺序队列，链式队列；静态顺序栈，动态顺序栈，链式栈；二叉树，线索二叉树；排序算
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 连续区间和(100分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
06-14 83
YA 在分析一组数据时，需要统计出有多少个连续区间（包括单个元素）的和大于等于给定的阈值 $x$。现在他将这个任务交给你，请你帮忙计算出满足条件的连续区间的数量。 ### 输入格式 第一行包含两个整数 $n$ 和 $x$，分别表示数组的长度和阈值。 第二行包含 $n$ 个正整数，表示给定的数组。 ### 输出格式 输出一个整数，表示满足条件的连续区间的数量。 ### 样例输入1 ``` 3 7 3 4 7 ``` ### 样例输出1 ``` 4 ``` ###
《征服数据结构》栈
数据结构和算法
06-12 211
摘要：1，栈的介绍2，栈的链表实现3，栈的数组实现1，栈的介绍栈(stack)又称堆栈，是一种特殊的线性表，只能对栈顶添加和删除元素，它是一种后进先出(LIFO, Last In First Out)的数据结构。栈的两种基本操作：压栈(push)和出栈(pop)。压栈：将数据放入堆栈顶端。出栈：将堆栈顶端数据移除。堆栈只能操作一端，我们前面讲过双端队列，就是两端都可以添加和删除元素，如果把双端队列...
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1209
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
数据结构(4):串
qq_64279967的博客
06-10 495
字符串数据结构三要数：逻辑结构、存储结构、运算子串必须是连续的！空格也是一个字符！每个空格字符占1B。
数据结构实验之链表七：单链表中重复元素的删除
06-06
好的，以下是中文回复： 单链表中重复元素的删除是数据结构实验中的一个重要内容。在这个实验中，我们需要编写程序来删除单链表中的重复元素，使得每个元素只出现一次。 具体来说，我们需要遍历整个单链表，对于每个节点，判断它的值是否已经出现过。如果已经出现过，则将该节点从链表中删除；否则，将该节点的值记录下来，继续遍历下一个节点。 需要注意的是，删除节点时需要注意链表的指针关系，否则会导致链表出现断裂。另外，为了方便记录每个节点的值是否已经出现过，我们可以使用一个哈希表来存储已经出现过的值。 总之，单链表中重复元素的删除是一个比较基础的数据结构实验，需要我们熟练掌握链表的基本操作和哈希表的使用方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值