数据结构与算法-单链表

已于 2023-10-07 16:53:06 修改
阅读量252 收藏 62
点赞数 65
分类专栏： 初阶数据结构与算法 文章标签： 链表 数据结构 c语言 c++
于 2023-10-06 23:54:54 首次发布
本文链接：https://blog.csdn.net/qq_73121173/article/details/133612446
版权

通过上一章对于顺序表的学习，我们了解到顺序表的优点是：以物理位置相邻表示逻辑关系，任一元素均可随机存储。但同时它也存在着缺陷：进行插入和删除操作时，需要移动大量的元素，存储空间不灵活。这里，我们给大家引入链表，该结构不要求逻辑上相邻的数据元素物理上一定相邻，且插入和删除元素时不需要移动数据元素，只需要修改指针值。

链表

🎈1.链表的概念及结构

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

在链式存储结构中，为了能正确表示结点间的逻辑关系，每个存储结点不仅要包含数据元素本身的信息（称为数据域），还必须存储数据元素之间的逻辑关系的信息，即指示其后继结点的地址（或位置）信息，这个信息称为指针。一般的，每个结点有一个或多个指针域。若一个结点中的某个指针域不需要指向任何其他结点时，则它的值置为空，通常用常量NULL表示。

与链式存储有关的术语：

  1. 结点：数据元素的存储映像，由数据域和指针域两部分组成。
  2. 链表：由n个结点由指针链组成一个链表
  3. 单链表、双链表、循环链表：
    (1). 结点只有一个指针域的链表称为单链表或者线性链表。
    (2). 结点由两个指针域的链表称为双链表。
    (3). 首尾相接的链表称为循环链表。
  4. 头指针、头结点和首元结点
    (1).头结点：是指向链表中第一个结点的指针。
    (2).首元结点：是指链表中存储第一个数据元素a1的结点。
    (3).头结点：是在链表的首元结点之前附设的一个结点。
    在这里插入图片描述

🔭1.1链表的分类

🏆单链表与双向链表：

如果每个结点除数据域外，仅设置一个指向后继的指针域，则这样构成的链表称为线性单向链表，称为单链表。在单链表中，由于每个结点只包含一个指向后继结点的指针，所以当访问一个结点后，只能依次访问其后继结点，但无法访问其前驱结点。
为此，引入了双向链表，该链表中每个结点除数据域外，设置两个指针域，一个指向前驱结点，一个指向后继结点，这样构成的链表称为线性双向链表，简称双向链表。该链表当访问一个结点后，既可以依次向后访问后继结点，也可以依次向前访问前驱结点。
🔎下面给出图示：单链表
双向链表

🏆对于单链表，又给出了两种分类标准：

📝带头结点与不带头结点：
在这里插入图片描述
📝循环与非循环：
在这里插入图片描述

🔭1.2数据结点的类型定义

在单链表中，假定每个结点的类型用LNode表示，它包括存储数据类型元素的数据域（data）和存储后继结点位置的指针域（next）。其数据类型定义如下：

typedef struct LNode//定义单链表结点类型
{
	ElemType data;//存放数据元素信息
	LNode* next;//存放后继结点的地址信息
}LNode;

在双向链表中，假定每个结点的类型用LNode表示，它包括存储数据类型元素的数据域（data）、存储前驱结点位置的指针域（prior）和存储后继结点位置的指针域（next）。其数据类型定义如下：

typedef struct DNode//定义双向链表结点类型
{
	ElemType data;//存放数据元素信息
	DNode* next;//存放后继结点的地址信息
	DNode* prior;//存放前驱结点的地址信息
}DNode;

🎈2.单链表

🔭2.1单链表的类定义

typedef int ElemType;
typedef struct LNode//定义单链表结点类型
{
	ElemType data;//存放数据元素信息
	LNode* next;//存放后继结点的地址信息
}LNode;
class LinkList
{
private:
	LNode* head;
public:
	LinkList();//构造函数，构造一个空表
	~LinkList();//析构函数，销毁函数
	void CreatList_h(int n);//头插法创建具有n个数据元素的线性链表
	void CreatList_t(int n);//尾插法创建具有n个数据元素的线性链表
	void InsertList(int i, ElemType e);//在表中第i个位置插入数据元素
	void DeleteList(int i, ElemType& e);//删除表中第i个元素的数据元素
	int GetElem(int i, ElemType& e);//获取第i个数据元素
	int LocateElem(ElemType e);//在链表中查找是否存在数据元素e，若存在，则返回1，否则返回0
	int ListLength();//计算表长
};

🔭2.2构造空链表

该操作由构造函数实现，申请一个头结点并置指针域为NULL。

LinkList::LinkList()
{
	head = new LNode;
	head->next = NULL;
}

🔭2.3销毁链表

该操作由析构函数实现，主要工作是依次释放链表中结点的存储空间。

LinkList::~LinkList()
{
	LNode* p = head;
	while (p)
	{
		head = head->next;
		delete p;
		p = head;
	}
}

在这里插入图片描述

🔭2.4头插法创建链表

该函数是从一个空表开始（初始化），依次读取数据，生成新结点，将读入的数据元素存放到新结点的数据域中，然后将新结点插入到当前链表的头结点后，直至读入所有数据为止。头插法建立单链表的示意图如下：
在这里插入图片描述

void LinkList::CreatList_h(int n)
{
	LNode* s;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = new LNode;//建立新结点
		cin >> s->data;//读入数据元素
		s->next = head->next;//新结点插入头结点之后
		head->next = s;
	}
}

该算法的时间复杂度为O(n),其中n为单链表中数据结点的个数。

🔭2.5尾插法创建链表

尾插法每次将新生成的结点插入到当前链表的表尾上。为此，需要增加一个尾指针rear,rear始终指向当前链表的尾结点。尾插法建立单链表的示意图如下：
在这里插入图片描述

void LinkList::CreatList_t(int n)
{
	LNode* rear, * s;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = new LNode;//建立新结点
		cin >> s->data;//读入数据
		rear->next = s;//新结点插在表尾
		rear = s;//尾指针指向新结点
	}
	s->next = NULL;//置最后结点的指针域为NULL
}

该算法的时间复杂度为O(n),其中n为单链表中数据结点的个数。

🔭2.6插入操作

该操作是在第i个结点前插入值为e的新结点。操作过程如下图所示：
在这里插入图片描述

void LinkList::InsertList(int i, ElemType e)
{
	LNode* p, * s;
	p = head;
	int j = 0;
	while (p && j < i - 1)//查找第i-1个结点
	{
		p = p->next; 
		j++;
	}
	if (!p || j > i - 1)
		return;
	else//插入新结点
	{
		s = new LNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
	}
}

🔭2.7删除操作

该操作是将单链表的第i个结点删去，也可以先找到第i-1个结点，然后删去它的后继结点，操作过程如下图所示：
在这里插入图片描述

void LinkList::DeleteList(int i, ElemType& e)
{
	LNode* p = head;
	int j = 0;
	while (p && j < i - 1)//查找第i-1个结点 
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)
		return;
	else
	{
		LNode* q = p->next;
		e = q->data;//保存被删除结点的数据元素
		p->next = q->next;//删除被删结点
		delete q;//释放空间
	}
}

🔭2.8取第i个元素

int LinkList::GetElem(int i, ElemType& e)
{
	LNode* p = head;
	int j = 0;
	while (j < i && p)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)//不存在第i个数据元素，返回0
		return 0;
	else
	{//存在第i个元素，返回1
		e = p->data;
		return 1;
	}
}

🔭2.9查找操作

该操作是在单链表中查找第一个值为e的结点，若存在这样的结点，则返回1，否则返回0.

int LinkList::LocateElem(ElemType e)
{
	LNode* p = head->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	if (p)//存在元素值为e的结点，返回1
		return 1;
	else//不存在，返回0
		return 0;
}

✅如果我们这里添加一条，如果找到了返回元素的位置，该怎么改这段代码呢？

int LinkList::LocateElem(ElemType e)
{
	LNode* p = head->next;
	int j = 1;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)//存在元素值为e的结点，返回位置
		return j;
	else//不存在，返回0
		return 0;
}

🔭2.10计算表长

ListLength()函数从单链表的第一个结点开始依次遍历整个链表，每遍历一个结点，计数器+1，最后返回结点数量。

int LinkList::ListLength()
{
	LNode* p = head->next;
	int count = 0;
	while (p)
	{
		count++;//计数器+1
		p = p->next;
	}
	return count;//返回结点个数
}

🔭2.11打印单链表

void LinkList::print()
{
	LNode* p = head->next;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

🔭2.12全部代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
typedef int ElemType;
typedef struct LNode//定义单链表结点类型
{
	ElemType data;//存放数据元素信息
	LNode* next;//存放后继结点的地址信息
}LNode;
class LinkList
{
private:
	LNode* head;
public:
	LinkList();//构造函数，构造一个空表
	~LinkList();//析构函数，销毁函数
	void CreatList_h(int n);//头插法创建具有n个数据元素的线性链表
	void CreatList_t(int n);//尾插法创建具有n个数据元素的线性链表
	void InsertList(int i, ElemType e);//在表中第i个位置插入数据元素
	void DeleteList(int i);//删除表中第i个元素的数据元素
	void GetElem(int i);//获取第i个数据元素
	void LocateElem(ElemType e);//在链表中查找是否存在数据元素e，若存在，则返回1，否则返回0
	void ListLength();//计算表长
	void print();//打印链表
};
LinkList::LinkList()
{
	head = new LNode;
	head->next = NULL;
}
LinkList::~LinkList()
{
	LNode* p = head;
	while (p)
	{
		head = head->next;
		delete p;
		p = head;
	}
}
void LinkList::CreatList_h(int n)
{
	LNode* s;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = new LNode;//建立新结点
		cin >> s->data;//读入数据元素
		s->next = head->next;//新结点插入头结点之后
		head->next = s;
	}
}
void LinkList::CreatList_t(int n)
{
	LNode* rear = NULL, * s = NULL;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = new LNode;//建立新结点
		cin >> s->data;//读入数据
		rear->next = s;//新结点插在表尾
		rear = s;//尾指针指向新结点
	}
	s->next = NULL;//置最后结点的指针域为NULL
}
void LinkList::InsertList(int i, ElemType e)
{
	LNode* p, * s;
	p = head;
	int j = 0;
	while (p && j < i - 1)//查找第i-1个结点
	{
		p = p->next; 
		j++;
	}
	if (!p || j > i - 1)
		return;
	else//插入新结点
	{
		s = new LNode;
		s->data = e;
		s->next = p->next;
		p->next = s;
	}
}
void LinkList::DeleteList(int i)
{
	ElemType e;
	LNode* p = head;
	int j = 0;
	while (p && j < i - 1)//查找第i-1个结点 
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)
		return;
	else
	{
		LNode* q = p->next;
		e = q->data;//保存被删除结点的数据元素
		p->next = q->next;//删除被删结点
		delete q;//释放空间
	}
	cout << "删除了单链表上的第" << i << "个元素，值为" << e << endl;
}
void LinkList::GetElem(int i)
{
	ElemType e;
	LNode* p = head;
	int j = 0;
	while (j < i && p)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)//不存在第i个元素
		cout << "不存在第i个数据元素"<<endl;
	else
	{//存在第i个元素
		e = p->data;
		cout << "第" << i << "个元素的值为" << e << endl;
	}
}
void LinkList::LocateElem(ElemType e)
{
	LNode* p = head->next;
	int j = 1;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)//存在元素值为e的结点，返回位置
		cout << e << "所在的位置为：" << j << endl;
	else//不存在，返回0
		cout << "不存在该数据元素" << endl;
}
void LinkList::ListLength()
{
	LNode* p = head->next;
	int count = 0;
	while (p)
	{
		count++;//计数器+1
		p = p->next;
	}
	cout << "表的长度为：" << count << endl;//返回结点个数
}
void LinkList::print()
{
	LNode* p = head->next;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
int main()
{
	LinkList L;
	L.CreatList_h(10);
	L.print();
	L.InsertList(3, 6);
	cout << "在第3个位置插入6后单链表为：";
	L.print();
	L.LocateElem(5);
	L.DeleteList(8);
	L.print();
	L.GetElem(3);
	L.ListLength();
	return 0;
}

✅示例运行:
在这里插入图片描述

好啦，关于单链表的知识点到这里就结束啦，后期会继续更新数据结构与算法的相关知识，欢迎大家持续关注、点赞和评论！❤️❤️❤️

一口⁵个团子
关注
  • 65
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 111
    评论
专栏目录
数据结构与算法-单链表的排序
04-21
数据结构与算法-单链表的排序
数据结构与算法-单链表的创建与操作
04-21
单链表的所有操作都有，文件里有两个头文件，一个cpp文件（运行时记得将最底下两个h文件单独拿出来）,非常整齐，说明也十分详细！
Java数据结构与算法--单链表常见面试题(新浪、百度、腾讯)
当一个合格的软件工程师
10-04 1762
此篇文章只是为了讲解链表常见面试题，与前面一篇【Java数据结构与算法–链表(Linked List)文章链接】文章是接着的。前一篇文章也有此部分代码，是非常完整的，是拿来就能用的。 单链表的常见面试题有如下: 1）求单链表中有效节点的个数。 代码如下： // 获取链表的长度（有效节点的个数） public int getLength(){ if (head.next==null){ return 0; } HeroNode current = head.next.
数据结构与算法 - 单链表逆转
极客学伟的技术分享社区
06-27 4191
数据结构与算法 - 单链表逆转 单链表逆转输出 方案一：head 作为已知首节点，最后节点指向null， 使用三个指针便利链表，逐个节点进行反转 实现思路图解： 实现代码： struct ActList { ActList * next; }; ActList * reverseList(ActList * head) { if (head ...
数据结构与算法-单链表-线性表转置
小林卡比的博客
08-23 1202
问题：《数据结构与算法分析（C++语言版）》p58 五、2 已知一个如下图所示的带头结点的单链表head（注：若头指针名是head，则把单链表称为表head），其存储结构为： ...
C/C++数据结构---单链表逆转（PTA）
敲代码嘞~的博客
09-27 1130
对于初次学习数据结构，一定要把最基础的，最简单的样例给写的十分熟练，自己每写一遍也将会增加对其结构的理解，为接下来更难的知识打好坚实的基础！一定一定不要一味的照着别人的代码敲，最后一定要自己独自去写！其中List/* 存储结点数据 *//* 指向下一个结点的指针 *//* 定义单链表类型 */L是给定单链表，函数Reverse要返回被逆转后的链表。
【数据结构与算法】 --- 单链表
m0_59649626的博客
02-03 78
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法设计-----单链表操作
apple_50916469的博客
03-26 1545
实验目的： 1、掌握线性表的链式存储结构的表示与实现。 2、掌握和验证单链表上各类操作的实现方法。 3、掌握C++编程中的一些基本编程规范。 实验要求： 实现单链表的基本操作 1）构造空的单链表； 2）建立含有若干数据元素的单链表并输出； 3）求表长； 4）获取第三个元素的值； 5）在第四个位置后，插入一个值为“38”的新的元素后输出单链表； 6）删除第五个位置上的元素后输出单链表； 测试数据：23 33 21 45 67 98 下面就以本次实验来讲解单链表操作的实现： 一、首先需要自定义一个结点类型的结构
数据结构与算法——单链表的逆序
icc_hhy的博客
05-21 962
在之前，了解了单链表结点的删除和插入之后，大家会发现这种具有方向性的链表结构中增删结点是相当容易的一件事。要从头到尾输出整个单链表也不难，但是如果要反转过来输出单向链表就需要某些技巧了。单向链表的结点特性就是知道下一个结点的位置，可是却无法得知它上一个结点的位置。因此下面将介绍2中方法来实现单链表的逆序操作。
python 数据结构与算法-单链表与顺序表的对比
zuyuhuo6777的博客
12-07 180
时间复杂度    
【数据结构与算法】单链表的插入和删除
一以贯之的努力 不得懈怠的人生
09-21 1万+
众所周知，顺序表中的每个结点中只存放数据元素，其优缺点为：优点：可随机存取，存储密度高；缺点：要求大片连续空间，改变容量不方便。而单链表中的每个结点除了存放数据元素外，还要存储指向下一个节点的指针，其优缺点为： 优点：不要求大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
单链表常见的几个面试题 新浪，腾讯内部面试题目 题目分析 代码实现 测试用例 一，面试题目 统计链表中有效节点的个数（不含头结点）【新浪】 获取链表中倒数第K个元素【新浪】 单向链表的逆转【腾讯】 二，题目分析...
【数据结构算法】--单链表的相关程序实现
03-09
压缩包包含单链表的listlink.h头文件,linkliist.c函数实现文件，test.c功能测试文件
【数据结构】一文了解二叉树的顺序结构（堆）
最新发布
tidal_wave的博客
05-18 724
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。以上就是今天要讲的内容，本文仅仅简单介绍了堆的使用，而堆提供了大量能使我们快速便捷地处理数据的思路。以后博主会继续介绍二叉树的其他知识，期待你的阅读。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 641
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
Pandas数据结构
eqwaak0的博客
05-15 958
类似表格中的一个列（column），类似于一维数组，可以保存任何数据类型。DataFrame是 Pandas 中的另一个核心数据结构，用于表示二维表格型数据。是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。
【数据结构1.0】归并排序
X__cheng的博客
05-18 311
本博客以排升序为例介绍归并排序！我们先看一个问题：有两组均为升序的数组要合并到一组数组当中，要求合并后的数组也是升序的，怎么办？办法：从头开始遍历两组数组，找“小”尾插到合并数组当中。举例如图：这其实是归并的思想！归并排序的基本思想：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。
数据结构------二叉树经典习题2
jj666mhhh的博客
05-18 468
-二叉树经典习题
数据结构与算法c语言单链表
09-19
单链表是一种经典的链式存储结构，它由一个包含数据和指向下一个节点的指针的节点构成。单链表的创建有头插法和尾插法两种方法。头插法将新创建的节点插入到头节点之后，而尾插法将新创建的节点插入到尾节点之后。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一口⁵个团子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值