【数据结构】1.2线性表的链式表示（单链表）

已于 2022-04-09 16:34:18 修改
阅读量891 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 线性表 单链表
于 2022-03-30 21:22:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50609545/article/details/123857181
版权

本文代码为学习总结，如果错误敬请指正！感谢各位大佬 😃

1.1线性表的顺序表示（顺序表）

文章目录

带头结点的单链表

结点定义

/*使用 typedef，之后可用于直接定义参数
	如LNode *GetElem (LinkList L)
	  LNode强调返回的是一个节点
	  LinkList强调L是一个单链表 
*/
typedef struct LNode{
	int data; 
	struct LNode *next;
}LNode,*LinkList;

初始化

//（带头结点的空表） 初始化
bool InitList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));//动态分配内存 
	if(L==NULL){//内存分配失败 
		return false;
	}
	//不管带不带头结点，头指针始终指向链表的第一个结点
	//而头结点是带头结点的链表中第一个结点，结点内通常不存储信息 
	L->next=NULL;//带头结点（若不带头结点，则可表示为L==NULL） 
	return true;
}

构建链表

头插法构建链表

//头插构建 （反向） 
//头插法的重要作用：链表的逆置 
LinkList List_HeadInsert(LinkList &L){
	printf("头插法构建链表：(以空格间隔、9999结束)\n"); 
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点 
	L->next=NULL;//初始为空链表（！！！！！！！必须得加 ） 
	scanf("%d",&x);//输入结点的值 
	while(x!=9999){//输入9999 表示结束 
		s=(LNode*)malloc(sizeof(LNode));//创建新结点（由系统生成一个LNode型的结点，同时将该节点的起始位置赋给指针变量s） 
		s->data=x;
		s->next=L->next;
		L->next=s;//L为头指针 
		scanf("%d",&x);
	}
	return L;
}

尾插法构建链表

//尾插构建,正向 
LinkList List_TailInsert(LinkList &L){
	printf("尾插法构建链表：(以空格间隔、9999结束)\n"); 
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点 
	LNode *s,*r=L;//r为表尾指针 
	L->next=NULL;//初始为空链表（！！！！！！！必须得加 ） 
	scanf("%d",&x);//输入结点的值 
	while(x!=9999){//输入9999 表示结束 
		s=(LNode*)malloc(sizeof(LNode));//创建新结点（由系统生成一个LNode型的结点，同时将该节点的起始位置赋给指针变量s） 
		s->data=x;
		r->next=s;
		r=s;//r指向新的表尾结点 
		scanf("%d",&x);
	}
	r->next=NULL;//尾结点指针置空，即为最后结点，下一结点为空 
	return L;
}

查找结点

按值查找结点

//按值查找（带头结点,头结点可以看为i=0） 
LNode *LocateElem(LinkList L,int e){
	LNode *p=L->next;//指向第一个结点 
	while(p!=NULL && p->data!=e){//查找数据域为e的结点 
		p=p->next;
	}
	return p; //找到后返回该指针，否则返回NULL 
}

按位序查找结点

//按位序查找（带头结点,结点可以看为i=0） 
LNode *GetElem(LinkList L,int i){
	if(i<0){
		return NULL;
	}
	if(i==0){
		return L;//头结点 
	} 
	LNode *p;//指针p指向当前扫描到的结点 
	int j=1;//当前p指向的是第几个结点 
	p=L->next;//L指向第一个结点 
	while(p!=NULL && j<i){//循环找到第i个结点 
		p=p->next;
		j++;
	}
	return p;//返回第i个头结点的指针，若大于表长，则返回NULL 
}

插入

在指定结点前插入

//前插，在p结点前插入元素e 
bool InsertPriorNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL){
		return false;
	}
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e; 
	return true;
}

在指定结点后插入

//后插，在p结点后插入元素e 
bool InsertNextNode(LNode *p,int e){
	if(p==NULL){//考虑到健壮性 
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL){//内存分配失败 
		return false;
	}
	s->data=e;
	s->next=p->next;
	p->next=s;//将s连到p之后 
	return true;
}

在指定位序插入元素

//按位序插入，在第i个位置插入元素e(带头结点)
bool ListInsert1(LinkList &L,int i,int e){
	if(i<1){
		return false;
	}
	
	LNode *p=GetElem(L,i-1);//找到第i-1个结点，等价于下面部分注释代码
//	LNode *p;
//	int j=0;
//	p=L;
//	while(p!=NULL && j<i-1){
//		p=p->next;
//		j++;
//	}

	return InsertNextNode(p,e); //后插，等价于下面部分注释代码
//	LNode *p;
//	if(p==NULL){
//		return false;
//	}
//	LNode *s =(LNode*)malloc(sizeof(LNode));
//	s->data=e;
//	s->next=p->next;
//	p->next=s;
//	return true;
}

求单链表长度

//求长度 （带头结点 ） 
int Length(LinkList L){
	int len=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}
	return len;
}

删除

按位序删除结点

//(带头结点)按位序删除
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1){
		return false;
	}
	LNode *p=GetElem(L,i-1);//找到第i-1个结点 ，等价于下面部分注释代码
//	LNode *p;
//	int j=0;
//	p = L;
//	while(p!=NULL && j<i-1){
//		p=p->next;
//		j++;
//	}
	if(p==NULL){
		return false;
	}
	if(p->next==NULL){
		return false;
	}
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;
}

删除指定结点

 //删除指定结点p
bool DeleteNode(LNode *p){
	if(p==NULL){
		return false;
	}
	LNode *q=p->next;//q指向*p的后继节点 
	p->data=p->next->data;//和后继节点交换数据域 
	p->next=q->next;//将*q结点从链中断开 
	free(q);//释放内存 
	return true;
}

打印输出

 //打印输出链表 
void PrintList(LinkList L){
	LNode *p=L->next;//指向第一个结点 
	if(p==NULL){
		printf("这是空链表！\n");
	}
	printf("表长为：%d\n",Length(L)); 
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;
	} 
}

完整代码及运行结果

代码

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

//结点定义 
#define MaxSize 50//线性表最大长度 

/*使用 typedef，之后可用于直接定义参数
	如LNode *GetElem (LinkList L)
	  LNode强调返回的是一个节点
	  LinkList强调L是一个单链表 
*/
typedef struct LNode{
	int data; 
	struct LNode *next;
}LNode,*LinkList;

//（带头结点的空表） 初始化
bool InitList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));//动态分配内存 
	if(L==NULL){//内存分配失败 
		return false;
	}
	//不管带不带头结点，头指针始终指向链表的第一个结点
	//而头结点是带头结点的链表中第一个结点，结点内通常不存储信息 
	L->next=NULL;//带头结点（若不带头结点，则可表示为L==NULL） 
	return true;
} 
 
//头插构建 （反向） 
//头插法的重要作用：链表的逆置 
LinkList List_HeadInsert(LinkList &L){
	printf("头插法构建链表：(以空格间隔、9999结束)\n"); 
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点 
	L->next=NULL;//初始为空链表（！！！！！！！必须得加 ） 
	scanf("%d",&x);//输入结点的值 
	while(x!=9999){//输入9999 表示结束 
		s=(LNode*)malloc(sizeof(LNode));//创建新结点（由系统生成一个LNode型的结点，同时将该节点的起始位置赋给指针变量s） 
		s->data=x;
		s->next=L->next;
		L->next=s;//L为头指针 
		scanf("%d",&x);
	}
	return L;
}

//尾插构建,正向 
LinkList List_TailInsert(LinkList &L){
	printf("尾插法构建链表：(以空格间隔、9999结束)\n"); 
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点 
	LNode *s,*r=L;//r为表尾指针 
	L->next=NULL;//初始为空链表（！！！！！！！必须得加 ） 
	scanf("%d",&x);//输入结点的值 
	while(x!=9999){//输入9999 表示结束 
		s=(LNode*)malloc(sizeof(LNode));//创建新结点（由系统生成一个LNode型的结点，同时将该节点的起始位置赋给指针变量s） 
		s->data=x;
		r->next=s;
		r=s;//r指向新的表尾结点 
		scanf("%d",&x);
	}
	r->next=NULL;//尾结点指针置空，即为最后结点，下一结点为空 
	return L;
}
 
 
//按值查找（带头结点,头结点可以看为i=0） 
LNode *LocateElem(LinkList L,int e){
	LNode *p=L->next;//指向第一个结点 
	while(p!=NULL && p->data!=e){//查找数据域为e的结点 
		p=p->next;
	}
	return p; //找到后返回该指针，否则返回NULL 
} 

//按位序查找（带头结点,结点可以看为i=0） 
LNode *GetElem(LinkList L,int i){
	if(i<0){
		return NULL;
	}
	if(i==0){
		return L;//头结点 
	} 
	LNode *p;//指针p指向当前扫描到的结点 
	int j=1;//当前p指向的是第几个结点 
	p=L->next;//L指向第一个结点 
	while(p!=NULL && j<i){//循环找到第i个结点 
		p=p->next;
		j++;
	}
	return p;//返回第i个头结点的指针，若大于表长，则返回NULL 
} 

//后插，在p结点后插入元素e 
bool InsertNextNode(LNode *p,int e){
	if(p==NULL){//考虑到健壮性 
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL){//内存分配失败 
		return false;
	}
	s->data=e;
	s->next=p->next;
	p->next=s;//将s连到p之后 
	return true;
} 

//前插，在p结点前插入元素e 
bool InsertPriorNode(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL){
		return false;
	}
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e; 
	return true;
} 

//按位序插入，在第i个位置插入元素e(带头结点)
bool ListInsert1(LinkList &L,int i,int e){
	if(i<1){
		return false;
	}
	LNode *p=GetElem(L,i-1);//找到第i-1个结点
//	LNode *p;
//	int j=0;
//	p=L;
//	while(p!=NULL && j<i-1){
//		p=p->next;
//		j++;
//	}

	return InsertNextNode(p,e); 
//	if(p==NULL){
//		return false;
//	}
//	LNode *s =(LNode*)malloc(sizeof(LNode));
//	s->data=e;
//	s->next=p->next;
//	p->next=s;
//	return true;
}
/*
//按位序插入，在第i个位置插入元素e(不带头结点)
bool ListInsert2(LinkList &L,int i,int e){
	if(i<1){
		return false;
	}
	if(i==1){
		LNode *s =(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;
		return true;
	} 
	LNode *p;
	int j=1;
	p=L;
	while(p!=NULL && j<i-1){
		p=p->next;
		j++;
	}
	return InsertNextNode(p,e); 
//	if(p==NULL){
//		return false;
//	}
//	LNode *s =(LNode*)malloc(sizeof(LNode));
//	s->data=e;
//	s->next=p->next;
//	p->next=s;
//	return true;
}
*/
//求长度 （带头结点 ） 
int Length(LinkList L){
	int len=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}
	return len;
}
 
//(带头结点)按位序删除
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1){
		return false;
	}
//	LNode *p;
//	int j=0;
//	p = L;
//	while(p!=NULL && j<i-1){
//		p=p->next;
//		j++;
//	}
	LNode *p=GetElem(L,i-1);//找到第i-1个结点 
	if(p==NULL){
		return false;
	}
	if(p->next==NULL){
		return false;
	}
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;
} 
 
 //删除指定结点p
bool DeleteNode(LNode *p){
	if(p==NULL){
		return false;
	}
	LNode *q=p->next;//q指向*p的后继节点 
	p->data=p->next->data;//和后继节点交换数据域 
	p->next=q->next;//将*q结点从链中断开 
	free(q);//释放内存 
	return true;
} 
 
//打印输出链表 
void PrintList(LinkList L){
	LNode *p=L->next;//指向第一个结点 
	if(p==NULL){
		printf("这是空链表！\n");
	}
	printf("表长为：%d\n",Length(L)); 
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;
	} 
} 

//打印输出结点
void PrintNode(LNode *s){
	printf("查找的结点为:%d\n",s->data);
} 

int main(){
	int i,e;
	bool flag;
	LNode *s;
	LinkList L1,L2,L3;
	InitList(L1);//初始化链表（带头结点） 
	InitList(L2);//初始化链表（带头结点）
	InitList(L3);//初始化链表（带头结点）
	PrintList(L1);//打印输出链表 
	PrintList(L2);//打印输出链表 
	PrintList(L3);//打印输出链表 
	printf("--------------------------------------------------------\n");
	List_HeadInsert(L1);
	PrintList(L1);//打印输出链表 
	printf("【按位序插入】\n请输入要插入的位序i：");
	scanf("%d",&i);
	printf("请输入要插入的值e：");
	scanf("%d",&e);
	flag=ListInsert1(L1,i,e);//按位序插入，成功true，失败false 
	if(flag){
		printf("插入成功，插入结点后的链表：\n");
		PrintList(L1);
	}else{
		printf("插入失败！\n");
	}
	printf("--------------------------------------------------------\n");
	List_TailInsert(L2);
	PrintList(L2);//打印输出链表
	printf("【按位序删除】\n请输入要删除的位序i：");
	scanf("%d",&i);
	flag=ListDelete(L2,i,e);
	if(flag){
		printf("删除成功，删除的值为：%d\n",e);
		printf("删除结点后的链表：\n");
		PrintList(L2);
	}else{
		printf("删除失败！\n");
	}
	printf("【按值删除】\n请输入要删除的值e：");
	scanf("%d",&e);
	s=LocateElem(L2,e);
	flag=DeleteNode(s);
	if(flag){
		printf("删除成功，删除的值为：%d\n",e);
		printf("删除结点后的链表：\n");
		PrintList(L2);
	}else{
		printf("删除失败！\n");
	}
	printf("--------------------------------------------------------\n");
	List_TailInsert(L3);//尾插构建链表（顺序） 
	PrintList(L3);//打印输出链表 
	printf("【按值查找结点】请输入要查找的值e：");
	scanf("%d",&e);
	s=LocateElem(L3,e);//按值查找，有则返回结点，无则返回NULL
	if(s==NULL){
		printf("查找的结点为NULL！\n");
	}else{
		PrintNode(s);//输出该结点的查找结果 
	}
	printf("【按位序查找结点】请输入位序i：");
	scanf("%d",&i);
	s=GetElem(L3,i); //按位序查找 ，有则返回结点，无则返回NULL
	if(s==NULL){
		printf("查找的结点为NULL！\n");
	}else{
		PrintNode(s);//输出该结点的查找结果 
	}
}

运行结果

这是空链表！
表长为：0
这是空链表！
表长为：0
这是空链表！
表长为：0
--------------------------------------------------------
头插法构建链表：(以空格间隔、9999结束)
5 4 3 2 1 9999
表长为：5
1
2
3
4
5
【按位序插入】
请输入要插入的位序i：3
请输入要插入的值e：55
插入成功，插入结点后的链表：
表长为：6
1
2
55
3
4
5
--------------------------------------------------------
尾插法构建链表：(以空格间隔、9999结束)
1 2 3 4 5 9999
表长为：5
1
2
3
4
5
【按位序删除】
请输入要删除的位序i：4
删除成功，删除的值为：4
删除结点后的链表：
表长为：4
1
2
3
5
【按值删除】
请输入要删除的值e：1
删除成功，删除的值为：1
删除结点后的链表：
表长为：3
2
3
5
--------------------------------------------------------
尾插法构建链表：(以空格间隔、9999结束)
1 2 3 4 5 9999
表长为：5
1
2
3
4
5
【按值查找结点】请输入要查找的值e：2
查找的结点为:2
【按位序查找结点】请输入位序i：6
查找的结点为NULL！
Selcouther
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
精心整理史上最全的数据结构flash演示动画，共5个版本，祝大家考研成功！
03-10
\数据结构flash演示\版本2\2.3 线性表的链式表示和实现-单链表到循环链表的转化.swf \数据结构flash演示\版本2\2.3 线性表的链式表示和实现-单链表的插入.swf \数据结构flash演示\版本2\2.3 线性表的链式表示和...
【数据结构】单链表的前插(按位序插入(带头结点和不带头结点）和按结点插入)
最新发布
bbt953的博客
10-12 462
单链表的前插(按位序插入(带头结点和不带头结点）和按结点插入)
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
海风依旧
11-17 5602
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
在单链表的头结点后插入一个结点
vener_的博客
09-24 1789
typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void Insert(LinkList &L,ElemType x) { if(L==NULL) return; LNode *s=(LNode*)malloc(sizeof(LNode)); s->data=x; s->next=L->next; L->next=s; } 2013年.
链表知识点（二）【单链表的插入操作】
u012512762的专栏
10-18 1482
【原理讲解】在p之后要插入一个结点s，首先最开始p->next 为Q，对于单链表的插入，首先建后链，后建前链。建后链的过程中，p->next始终未Q。
线性表的链式表示
qq_39321234的博客
03-11 408
在循环单链表中，表尾结点*r的next域指向L，故表中没有指针域为NULL的结点，因此，循环单链表的判空条件不是头结点的指针是否为空，而是它是否等于头结点。在循环双链表L中，某结点*p为尾结点时，p->next==L；删除结点可用删除*p的后继结点来实现，本质就是将其后继节点的值赋予其自身，然后删除后继结点，这样使得时间复杂度为O(1)将新结点插入到当前链表的表尾，为此必须增加一个尾指针r，使其始终指向当前链表的尾结点。采用头插法建立单链表时，读入数据的顺序与生成的链表中的元素的顺序是相反的。
数据结构(C#语言版)
05-13
第2章至第6章分别讨论了线性表、栈和队列、串和数组、树型结构和图结构等常用的数据结构及其应用，以及在.NET框架中相应的数据结构；第7、8两章分别讨论了排序和查找常用的各种方法及其应用以及在.NET框架中相应的...
C#数据结构
12-20
第2章至第6章分别讨论了线性表、栈和队列、串和数组、树型结构和图结构等常用的数据结构及其应用，以及在.NET框架中相应的数据结构；第7、8两章分别讨论了排序和查找常用的各种方法及其应用以及在.NET框架中相应的...
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
2.3　线性表的链式表示和实现　24 2.3.1　单链表的定义和表示　24 2.3.2　单链表基本操作的实现　26 2.3.3　循环链表　31 2.3.4　双向链表　32 2.4　线性表的应用　34 2.4.1　一般线性表的合并　34 2.4.2　有序表的...
线性表的链式表示：链表详解
ln_acmc的博客
03-20 2326
文章目录（一）链表的定义 （一）链表的定义 线性表的链式存储结构即链表，其特点是用一组**任意**的存储单元存储线性表的数据元素，这组在内存 中的存储单元可以是连续的，也可以是不连续的。链表，顾名思义，是由各个节点链接。节点的信息包含**数 据域**和**指针域**。数据域存储元素信息，指针域用来存储直接后继节点的地址（两节点间的箭头）。n个节点 链接成一个链表，每个元素节点都只有一个指针域，又称为**单链表**。 (https://img-blog.csdnimg.cn/20210320160
线性表-链式表示和实现
11-10
本文档是有关使用c++，完成对线性表的链式存储实现的代码，包括了链表的插入、删除、查找、返回值等
数据结构---线性表的链式表示
qq_63976098的博客
10-13 642
单链表，线性表的链式表示。
数据结构-线性表的链式表示
weixin_46441425的博客
04-12 1156
【数据结构】线性表的链式表示
WINGREZ‘S BLOG
07-31 1563
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等...专题介绍 线性表的链式表示 线性表的链式表示即用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可...
线性表链式表示和实现（C语言)
热门推荐
世纪末的架构师的博客
11-07 1万+
线性表链序表示和实现（C语言) 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，而线性表的链式存储特点则是用一组任意的存储单元存储线性表的数据元素。这组存储单元既可以是连续的，也可以是不连续的。 对于链式存储的每个数据元素而言，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息，即直接后继的存储位置。这两部分信息组成了数据元素的存储映像，称为结点。 链式存储的结构包含两个域：一个用于存储数据元素的信息，另一个用于存储直接后继的存储位置；存储数据元素信息的域称为数据域，存储直
数据结构——线性表的链式表示
Tyler_Zx的博客
07-17 3640
线性表的定义 线性表是具有相同数据类型的n(n >= 0)个数据元素的有限序列。其中n为表长，当n = 0时，该线性表是一个空表。若用L命名线性表，其一般表示为：L = (a1, a2, ..., ai, ai+1, ..., an)。其中a1是唯一的”第一个”数据元素，an是唯一的”最后一个”数据元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直...
数据结构—习题2.7 链表翻转（递归与迭代两种实现）LeetCode（206）
小虾米编程
07-03 487
链表的翻转是程序员面试中出现频度最高的问题之一，常见的解决方法分为递归和迭代两种。最近在复习的时候，发现网上的资料都只告诉了怎么做，但是根本没有好好介绍两种方法的实现过程与原理。所以我觉得有必要好好的整理一篇博文，来帮忙大家一步步理解其中的实现细节。 我们知道迭代是从前往后依次处理，直到循环到链尾；而递归恰恰相反，首先一直迭代到链尾也就是递归基判断的准则，然后再逐层返回处理到开头。总结来说，链...
第2章线性表的基本使用及其cpp示例（第二章汇总,线性表都在这里）
weixin_45694388的博客
03-14 411
2.1线性表的定义和特点 【类型定义： *是n个元素的有限序列 *除了第一个元素没有直接前驱和最后一个没有直接后驱之外，其余的每个元素只有一个直接前驱和直接后驱； （a1,a2…an） 【特征： *有穷性：由有限个元素组成，元素个数表长度 n=0空表 （a1,a2…an），称下标i为线性表的位序 *有序性： 线性表元素之间存在严格次序关系（序偶关系） *同一性：线性表属于同类数据元素组...
C语言数据结构如何从线性表得到单链表
03-31
线性表是一种数据结构，它包含一组有序的元素，每个元素都有一个唯一的编号。线性表可以使用数组或链表来实现。而单链表是一种链式存储结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 如果要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Selcouther

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

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

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

打赏作者

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

抵扣说明：

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

余额充值