数据结构：单链表

已于 2024-06-06 23:09:41 修改
阅读量751 收藏 4
点赞数 1
分类专栏： 算法 数据结构 C++ 文章标签： 数据结构
于 2024-06-05 20:03:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67035108/article/details/127081713
版权
C++ 同时被 3 个专栏收录
28 篇文章 3 订阅
订阅专栏
数据结构
10 篇文章 0 订阅
订阅专栏
算法
8 篇文章 0 订阅
订阅专栏

目录

        1.实现思想

        2.包含头文件

        3.结点设计

        4.接口函数定义

        5.接口函数实现

实现思想

        单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据部分和指向下一个节点的指针。单链表的特点是每个节点只包含一个指向下一个节点的指针，因此只能从表头向表尾遍历。下面是单链表的一些基本特性和操作：

  1. 线性结构：数据元素之间是一对一的关系。
  2. 动态数据结构：在运行时可以增加或删除节点。
  3. 非连续性：数据元素在内存中不是连续存储的，每个节点通过指针指向下一个节点。
  4. 插入和删除节点：在链表的指定位置插入新节点，删除链表中的指定节点。
  5. 遍历链表：从表头开始，通过每个节点的指针访问下一个节点。
  6. 查找节点：查找链表中特定值的节点。
  7. 反转链表：将链表的节点顺序反转

包含头文件

#include<stdio.h>
#include<stdlib.h>

结点设计

#define Initsize 10
typedef int Elemtype;
 
typedef struct {
	Elemtype data[Initsize];	//定义数组data大小为Initsize，存储的是静态顺序表的数据
	Elemtype* next;				//定义next为Elemtype类型的指针，用于动态扩展顺序表的大小
	int Maxsize;				//定义变量Maxsize存储顺序表的大小
	int lenth;					//定义变量lenth存储顺序表所存储的数据个数
}SqlList;

/*以上封装等同于以下代码:
typedef struct LNode LNode;
typeddf struct LNode* LinkList;
*/

接口函数定义

bool InitList(LinkList& A);			 //定义函数InitList用于初始化不带头结点的单链表
bool CheckList(LinkList& A);		 //定义函数CheckList用于查看不带头结点的单链表是否为空
bool InitNodeList(LinkList& A);		 //定义函数InitNodeList用于初始化带头结点的单链表
bool CheckNodeList(LinkList& A);	 //定义函数CheckNodeList用于查看带头结点的单链表是否为空
bool CheckOrder(LinkList& A,int len);//定义函数CheckOrder用于遍历链表查找结点并判空
bool InsertNextNode(LNode* A, Elemtype X);//定义函数InsertNextNode用于在指定结点进行后插操作
bool ListDelete(LinkList& A, int len, Elemtype X);//定义函数ListDelete用于按位序删除数据
bool NodeDelete(LNode* A);          //定义函数NodeDelete用于指定结点删除数据
LNode* GetElem(LinkList& A,int len);//定义函数GetElem用于获取结点元素
LNode* LocateElem(LinkList& A, Elemtype X);//定义函数LocateElem用于按值查找结点
int ListLength(LinkList& A);		//定义函数ListLenth用于查看单链表的长度
bool LoopCheckList(LinkList& A);	//定义函数LoopCheckList用于循环遍历输出单链表中的元素

//定义函数ListNodeInsert用于在带头结点单链表中执行按位序插入
bool ListNodeInsert(LinkList& A,int len,Elemtype X);
//定义函数ListInsert用于在不带头结点的单链表中执行按位序插入
bool ListInsert(LinkList& A, int len, Elemtype X);
//定义函数InsertPriorNode用于在指定结点进行前插操作
bool InsertPriorNode(LNode* A, Elemtype X);
//定义函数NextManyElemList用于使用尾插法建立多个元素的单链表
bool NextManyElemList(LinkList& A);
//定义函数PrioeManyElemList用于使用头插法建立多个元素的单链表
bool PriorManyElemList(LinkList& A);	
/*函数中带有&的形参意义解读:
属于CPP文件中的引用，指将指针另取其名，使用时可以引用指针(类似typedef函数)
如:LinkList& A ——>将传入的LihkList参数另取其名为A(调用A等同于调用该实参)
*/

接口函数实现

bool LoopCheckList(LinkList& A) {//定义函数LoopCheckList用于循环遍历输出单链表中的元素
	LNode* Q = A->next;
	printf("单链表中所含的数据为:");
	while (Q!=NULL) {					//遍历输出单链表
		printf("   %d", Q->data);
		Q = Q->next;
	}
	return true;
}

bool PriorManyElemList(LinkList& A){
    //定义函数PrioeManyElemList用于使用头插法建立多个元素的单链表
	int len, J = 0;
	LNode* Q = A;
	Elemtype X;
	printf("请输入要输入的数据个数:");
	scanf_s("%d", &len);
	printf("请输入数据");
	while (J < len) {
		scanf_s("%d", &X);
		InsertPriorNode(Q, X);//调用函数InsertPriorNode用于在指定结点进行前插操作
		printf("\n");
		J++;
	}
	printf("使用头插法建立大小为%d的单链表成功", len);
	return true;
}
bool NextManyElemList(LinkList& A) {						
    //定义函数NextManyElemList用于使用尾插法建立多个元素的单链表
	int len,J=0;
	LNode* Q = A;
	Elemtype X;
	printf("请输入要输入的数据个数:");
	scanf_s("%d", &len);
	printf("请输入数据");
	while (J < len) {
		scanf_s("%d", &X);
		InsertNextNode(Q, X);//调用函数InsertNextNode用于在指定结点进行后插操作
		Q = Q->next;
		printf("\n");
		J++;
	}
	printf("使用尾插法建立大小为%d的单链表成功", len);
	return false;
}

int ListLength(LinkList& A) {//定义函数ListLenth用于查看单链表的长度
	LNode* Q = A;			 //定义LNode指针指向头指针所含的指针域
	int len = 0;			 //定义变量len存储单链表长度
	while (Q->next != NULL) {//遍历单链表
		Q = Q->next;
		len++;
	}
	return len;
}

LNode* LocateElem(LinkList& A,Elemtype X) {	//定义函数LocateElem用于按值查找结点
	LNode* Q = A->next;						//定义LNode指针指向头指针所含的指针域
	while (Q != NULL && Q->data != X) {		//遍历单链表，寻找数据域为X的结点
		Q = Q->next;
	}
	if (Q == NULL) {						//判断单链表中是否存在满足条件的结点
		printf("不存在数据域为%d的结点", X);
	}
	else {
		return Q;
	}
}

LNode* GetElem(LinkList& A,int len) {		//定义函数GetElem用于获取结点元素
	if (len < 0) {							//判断传入的结点是否有误	
		printf("输入的结点次序有误");
		return A;
	}
	LNode* Q = A;							//定义LNode指针指向传入的头指针
	int J = 0;
	while (Q != NULL && J < len) {			//遍历单链表寻找传入次序的结点
		Q = Q->next;
		J++;
	}
	return Q;
}

bool NodeDelete(LNode* A) {					//定义函数NodeDelete用于指定结点删除数据
	if (A == NULL) {
		printf("传入的结点不存在");
		return false;
	}
	if (A->next == NULL) {
		printf("传入的结点为最后一个结点，需要遍历单链表才能删除该结点");
		return false;
	}
	LNode* Q = A->next;
	A->data == Q->data;
	A->next = Q->next;
	free(Q);
	printf("传入的结点已删除");
	return true;
}

bool ListDelete(LinkList& A, int len, Elemtype X) {//定义函数ListDelete用于按位序删除数据
	LNode* Q = A;							//定义一个LNode指针Q指向传入的单链表A
	if (CheckOrder(Q, len)) {				//调用函数CheckOrder寻找传入次序的前驱结点
		if (Q->next == NULL) {				//查看其传入的结点的前驱结点里的指针域next是否为空
			printf("输入的结点不存在");
			return false;
		}
		LNode* W = Q ->next;				//定义一个LNdoe指针W指向前驱结点的指针域next
		X = W->data;						//获取删除的结点的数据域data
		Q->next = W->next;					//更新前驱结点的数据域next
		printf("指定次序的单链表已删除，其删除的数据域为:%d", X);
		free(W);							//使用函数free释放删除的结点空间
		return true;
	}
	else {
		return false;
	}
}

bool InsertPriorNode(LNode* A, Elemtype X) {
    //定义函数InsertPriorNode用于在指定结点进行前插操作
	if (CheckList(A)) {					//判断插入的结点是否为空
		printf("传入的结点不存在");
		return false;
	}
	LNode* Q = (LNode*)malloc(sizeof(LNode));		//向计算机申请一个大小为LNode的空间
	if (CheckList(Q)) {					//判断使用malloc1函数是否申请到空间
		printf("计算机内存不足，无法分配空间创建链表插入");
		return false;
	}
	Q->data = X;					//进行单链表的前插操作，并更新数据
	Q->next = A->next;
	A->next = Q;
	printf("在指定结点前执行前插操作成功，其数据域保存的数据为%d", X);
	return true;
}

bool InsertNextNode(LNode *A, Elemtype X) {//定义函数InsertNextNode用于在指定结点进行后插入
	if (CheckList(A)) {					//判断插入的结点是否为空
		printf("传入的结点不存在");
		return false;
	}
	LNode* Q = (LNode*)malloc(sizeof(LNode));		//向计算机申请一个大小为LNode的空间
	if (CheckList(Q)) {					//判断使用malloc1函数是否申请到空间
		printf("计算机内存不足，无法分配空间创建链表插入");
		return false;
	}
	Q->next = A->next;					//进行单链表的后插操作，并更新数据
	A->next = Q;
	Q->data = X;
	printf("在指定结点后执行后插入成功，其数据域保存的数据为%d", X);
	return true;
}

bool ListInsert(LinkList& A, int len, Elemtype X) {
    //定义函数ListInsert用于在不带头结点的单链表中执行按位序插入
	if (len == 1) {				//传入的次序为1的情况
		LNode* W = (LNode*)malloc(sizeof(LNode));
		W->next = A;			
		W->data = X;
		A = W;					//更新头指针指向的地址
		printf("在次序%d中插入单链表成功，其存储的数据为%d", len, X);
		return true;
	}
	ListNodeInsert(A,len,X);	//调用函数ListNodeInsert执行后插操作
}

bool ListNodeInsert(LinkList& A, int len, Elemtype X) {				
    //定义函数ListNodeInsert用于在单链表中执行按位序插入
	LNode* Q = A;					//定义一个LNode指针Q指向传入的单链表A
	if (CheckOrder(Q, len)) {		//调用函数CheckOrder寻找传入次序的前驱结点
		LNode* W = (LNode*)malloc(sizeof(LNode));	//定义LNode指针W指向新开辟的大小为LNode的空间
		W->data = X;				//更新单链表数据
		W->next = Q->next;
		Q->next = W;
		printf("在次序%d中插入单链表成功，其存储的数据为%d", len, X);
		return true;
	}
	else {
		return false;
	}
}

bool CheckOrder(LinkList& A, int len) {//定义函数CheckOrder用于遍历链表查找结点并判空
	if (len < 1) {				//判断传入的次序是否合法
		printf("传入的次序过小");
		return false;
	}
	LNode* W = A;					//定义一个LNode型的指针存储传入的头结点地址
	int J = 0;					//定义变量J用于循环便利单链表
	while (W != NULL && J < len - 1) {			//遍历单链表，寻找满足该次序的前驱结点
		W = W->next;
		J++;
	}
	if (W == NULL) {			//判断传入的次序是否合法
		printf("传入的次序过大");
		return false;
	}
	A = W;						//改变传入的单链表A指向的地址
}

bool CheckNodeList(LinkList& A) {//定义函数CheckNodeList用于查看带头结点的单链表是否为空
	return (A->next == NULL);
}

bool InitNodeList(LinkList& A) {			//定义函数InirNodeList用于初始化带头结点的单链表
	A = (LNode*)malloc(sizeof(LNode));		//使用函数malloc向计算机申请一片大小为LNode类型的空间，将其地址强转为LNode型
	if (CheckList(A)) {						//判断申请的空间是否成功
		printf("计算机内存不足，初始化带头结点的单链表失败");
		return false;
	}
	A->next = NULL;							//将头结点所含的指针域next值指向空(头结点不存储数据域data)
	printf("初始化带头结点的单链表成功");
	return true;
}


bool CheckList(LinkList& A) {//定义函数CheckList用于查看链表是否为空
	return (A == NULL);	
}

bool InitList(LinkList& A) {//定义函数InitList用于初始化不带头结点的单链表
	A = NULL;				//将传入的单链表A赋值为NULL，意为课表
	printf("初始化不带头结点的单链表成功\n");
	return true;
}
Wild_Pointer.
关注
专栏目录
单链表的实现（C语言）
qq_45731531的博客
11-05 291
什么是单链表 由n个只含有一个指针域的结点（node）构成的线性表称为单链表 单链表的实现 .h文件 #include <stdio.h> #include <stdlib.h> #define _NODE_H_ typedef struct list{//定义一个结构体类型作为结点 int date; struct list *next; }Node;//typede...
c语言中node是数据类型吗,lnode(数据结构lnode是什么类型)
热门推荐
weixin_32916125的博客
05-23 2万+
请问LNode在C语言中代表什么，英语全称是什么是数据结构中定义链表的英文名称，代表链表中的结点， 可以查阅c中链表那一章的相关内容.数据结构Lnode *是代表什么！？？大侠 谢谢！！是一个 指针类型是吗？？？.你好！再清楚一些 Lnode应该是 结构、枚举、共用体、自定义类型等 (要看程序怎么定义的) Lnode*表示相应的结构指针或其它的指针 从命名方式来看 应该是.typedef stru...
关于数据结构（c语言）中结构体声明的LNode, *LinkList
ChunkWen的博客
09-12 8632
typedef int ElemType; typedef struct LNODE{//这里的LNODE称为结构标记 ElemType data;//节点的数据域 struct LNODE* next;//定义一个指向结构体的指针变量，保存下一个节点的地址信息 }LNode,*LinkList; //这里的LNode是结构体的别名，不是结构变量名 //而LinkList是struct LNode * 的别名 //整个上述结构体可等价为： struct LNODE{}; typedef
【数据结构】关于单链表中的LNode与*LinkList
bbt953的博客
10-10 2849
关于单链表中的LNode与*LinkList
数据结构和算法
u010901792的专栏
08-28 240
数据结构和算法 单链表 struct Node { int data; Node *nextNode; }; 创建列表 Node *CreatList() { Node *head,*p,*s; int cycle=1,x; int count=0; head=(Node*)malloc(sizeof(Node)); p=head;...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
单链表是一种线性数据结构，每个元素（节点）包含两个部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点的地址。单链表的头节点通常用来初始化链表，其指针域指向第一个元素。插入和删除操作...
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1240
数据结构：单链表的基本操作
数据结构链表：单链表的代码实现
最新发布
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
Java实现数据结构：单链表与循环链表详解
本文档主要介绍了在Java中实现数据结构与算法的相关知识，重点讲解了单链表、循环单链表和循环双链表的基础概念、操作方法以及其实现细节。以下是各部分的详细说明： 1. **单链表**: - **链表定义**：链表是一种...
南通学院数据结构：单链表的插入与删除实验详解
本实验报告主要关注数据结构中的单链表插入和删除操作，针对的是南通纺织职业技术学院的数据结构课程。学生郑璐在指导教师庄国强的指导下，对顺序表和单链表这两种线性表的数据结构进行了深入研究。 在顺序表部分，...
数据结构之C语言实现单链表
five-five
05-13 1678
数据结构之C语言实现单链表定义什么是单链表用代码定义一个单链表typedef使用不带头节点带头结点基本操作的实现插入删除操作查找操作单链表的建立 定义 什么是单链表 优点：不要求大片不连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针 用代码定义一个单链表 struct LNode{ ElementType data; struct LNode *next; } struct LNode* p=(struct LNode*)malloc(sizeof(struct LNod
数据结构第二章（单链表部分）学习笔记
qq_62175345的博客
04-05 4270
线性表---单链表部分 1、知识承接 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式来表示。但效率低插入和删除操作需要移动大量的元素。临时扩大存储空间有困难，存储分配只能预先进行必须占用地址连续的内存空间 . 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动大量的元素，只需要修改指针，但也会失去顺序表可以随机存取的优点。 单链表 链表： 通过一组任意的
数据结构链表小结（一）
天涯小菜鸡的博客
01-02 806
0）头指针是指链表指向第一个节点的指针，若链表有头结点，则是指向头结点的指针 1）头指针具有标志作用，所以常用头指针冠以链表的名字 2）无论链表是否为空，头指针均不为空 3）头指针是链表的必要元素 4）链表结构体 typedef struct Node { ElemType data; //数据域 struct Node *Next; // 指针域
struct lnode是什么结构类型_从零开始学习数据结构>哈希表
weixin_39768444的博客
10-21 409
哈希表的本质就是 K-V 结构，V 可以是链表、数组、数组链表等形式，需要灵活掌握这些数据结构，在代码实现，才能真正的掌握。1、哈希表理想情况是不希望经过任何比较，一次存取，便可以直接定位，这是需要一种映射关系，我们把这个映射关系就叫为哈希函数。哈希表在对大数据的处理查找上，有明显优势。若数据有序，--->我们一般会想到二分查找；但是哈希查找更加犀利；针对哈希查找，我们主要学习：(...
数据结构——结构体的注意事项
yiluxiangbei2018的博客
09-21 212
结构体定义一个单链表 方式一： typedef struct LNode { int data; //定义每个节点存放一个数据 struct LNode *next; //定义指针指向下一个节点 }LNode, *LinkList; 方式二： struct LNode{ int data; struct LNode *next; }; typedef struct LNode LNode; typedef struct LNode *LinkList;//指向struck LNode的指针
数据结构——单链表（小白入门第二天）
qq_50645064的博客
07-16 5031
小白自学进阶道路
数据结构--单链表的定义
m0_60593173的博客
06-27 523
单链表的定义（如何用代码实现）优点:不要求大片连续空间，改变容量方便缺点:不可随机存取，要耗费一定空间存放指针。
数据结构—单链表的各种基本操作
wu_comet的博客
07-03 1221
//建立一个单链表 #include&lt;stdio.h&gt;#include&lt;stdlib.h&gt; //malloc的头文件 //1.先定义单链表中的结点类型 typedef int ElemType; //自定义ElemType的类型为整型 typedef struct Lnode{ //自定义的结构体型  ElemType data;    //结点的数据域  struct L...
数据结构单向链表（C++）
qq_45852561的博客
05-20 400
head文件 #include<iostream> #define status int #define OK 1 #define ERROR 0 using namespace std; typedef int elemType; #include"head.h" //单链表结点数据结构 typedef struct LNode{ elemType data;//数据域 struct LNode *next;//指针域 }LNode,*LinkList;//linklist是指.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wild_Pointer.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值