数据结构——顺序表里面的单链表介绍

已于 2023-03-23 19:03:47 修改
阅读量535 收藏 2
点赞数
分类专栏： 数据结构与C语言算法以及数据挖掘介绍 文章标签： 数据结构 c# 开发语言 链表 大数据
于 2023-03-02 21:12:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56006701/article/details/129308652
版权

系列文章目录

栈的基本操作实现算法_张小鱼༒的博客-CSDN博客

文章目录

前言

本文仅简单介绍单链表这种数据结构

以下是本篇文章正文内容，下面案例可供参考

一、顺序结构的链式表示——单链表

1.链表的相关介绍

1.1链表的概念及结构

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

在链表（SListl）当中，每个节点（SListNode）都存储着一个数据（data)，还有一个指向下个节点的指针（next）

1.2、单链表

单链表用结点存储了数据以及下一个结点的地址，因此结点一般分为多个部分，即数据域与指针域，数据域存储有效数据，指针域存储下一个结点的地址。同时单链表有只有一个指针域，双链表有两个指针域。同时其最后一个节点是指向一个空指针。

  • 离散的数据分布在存储空间内
  • 非随机存取
  • 头指针表示单链表【指向链表的第一个节点】
  • 头结点——带头结点的链表中的第一个结点，且结点不存储信息

1.3、单链表的优缺点

  • 1.优点：可以按照实际所需创建结点增减链表的长度，更大程度地使用内存。
  • 2.缺点：进行尾部或者任意位置上插入或删除时时间复杂度和空间复杂度较大，每次都需要通过指针的移动找到所需要的位置，相对于顺序表查找而言效率较低。

1.4、补充：顺序表的优缺点

  • 1.优点：可以通过下标直接访问所需要的数据
  • 2.缺点：不能按实际所需分配内存，只能使用malloc或者realloc函数进行扩容，容易实现频繁扩容，容易导致内存浪费与数据泄露等问题。

二、单链表的一些基本操作与结构定义

1、单链表的实现

下面我们实现的单链表是很多数据结构的子结构，也就是单向不带头非循环链表。

2、单链表的结构定义

单链表的结构与顺序表是完全不同的，分为俩个部分数据域和指针域

typedef struct SListNode
{
    int data;
    struct  SListNode* next;//存储下一个节点的地址
}SListNode;

我们也可以使用typedef操作符重命名，方便后面接口操作。

3、单链表结点的创建

单链表的创建，不用像顺序表一样需要初始化的，是由一个个节点组成，需要多少个结点就创建多少个结点，我们可以单独写出一个测试函数测试单链表的创建，方便调试，下面我们利用上面这个结构创建一个单链表。

4、单链表的基本操作接口

 typedef int SLTDataType;//统一数据类型
 SLTDataType* BuySListNode(SLTDataType x);//申请结点
 void SListPrint(SListNode* phead);//打印链表
 void SListPushBack(SListNode** pphead, SLTDataType x);//尾插
 void SListPushFront(SListNode** pphead, SLTDataType x);//头插
 void SListPopBack(SListNode** pphead);//尾删
 void SListPopFront(SListNode** pphead);//头删
 
 SLTDataType *SListFind(SListNode* pphead, SLTDataType x);//查找
 //在pos位置之前插入（pos第几个元素的地址）
 //和顺序表的下标越界不同，链表不存在下标，pos地址必须为find函数找到
 void SListInsert(SListNode** pphead, SListNode*pos, SLTDataType x);
 //在pos位置之后插入
 void SListInsertAfter(SListNode* pos, SLTDataType x);
//删除pos位置
void SListErase(SListNode** pphead, SListNode* pos);
//删除pos下一位的位置
void SListEraseAfter( SListNode* pos);

void SListDestroy(SListNode** pphead);//摧毁链表

5、主要的几种操作介绍

5.1、头插法建立单链表

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

//单链表的结构定义 
typedef struct LNode
{
	int data;			//data存放结点数据域 
	struct LNode *next;	//指向后继结点的指针 
}LNode;					//定义单链表结点类型 
//头插法建立单链表
void createlistF(LNode *&L, int a[], int n)
{
	LNode *s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));
	L ->next = NULL;
	for(i=0;i<n;++i)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s ->data = a[i];
		//下面两句为头插法的关键步骤 
		s ->next = L ->next;	//s所指新结点的指针域next指向L中的开始结点 
		L ->next = s;			//头结点的指针域next指向s结点，使得s成为新的开始结点 		
	}
 } 
 //打印链表数据 
 void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		
		{
			printf("\n");
		}
	}
	printf("\n");
 } 
 int main()
 {
 	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	}	
	//测试头插法建立链表
	createlistF(L,a,n);
	//查看建立后的链表 
	printfList(L);
	return 0;
 }

5.2尾插法建立单链表

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

typedef struct LNode
{
	int data;			//data中存放结点的数据域 
	struct LNode *next;	//指向后继结点的指针 
 }LNode; 				//定义单链表结点类型
 
 
 
 
//尾插法建立链表
void createlistR(LNode *&L, int a[], int n) //要改变的变量用引用型 
{
	LNode *s,*r;		//s用来指向新申请的结点，r之中指向L的终端结点 
	int i;
	L = (LNode *)malloc(sizeof(LNode));		//申请L的头结点空间 
	L -> next = NULL;
	r = L;				// r指向头结点，因为此时头结点就是终端结点 
	for(i=0;i<n;++i)	// 循环申请n个结点，来接受数组a中的元素 
	{
		s = (LNode*)malloc(sizeof(LNode));	// s指新申请的结点 
		s ->data = a[i];// 用新申请的结点来接受a中的一个元素 
		r ->next = s;	// 用来接纳新结点 
		r = r ->next;	// r指向终端结点，以便于接纳下一个到来的结点 
	}
	r ->next = NULL;	// 数组a中所有的元素都已经装入链表L中，L的终端结点的指针域置为NULL，L建立完成 
 } 
 
 //打印链表数据 
  void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		//计数器
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		//每5个元素作为一行
		{
			printf("\n");
		}
	}
	printf("\n");

 }

int main()
{
	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	 }
	 
	//测试尾插法建立链表 
	createlistR(L,a,n);
	
	//查看建立后的链表 
	printfList(L);
	
	return 0;
	
}

5.3、查找结点

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

//单链表的结构定义 
typedef struct LNode
{
	int data;			//data存放结点数据域 
	struct LNode *next;	//指向后继结点的指针 
}LNode;					//定义单链表结点类型 


//头插法建立单链表
void createlistF(LNode *&L, int a[], int n)
{
	LNode *s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));
	L ->next = NULL;
	for(i=0;i<n;++i)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s ->data = a[i];
		s ->next = L ->next;
		L ->next = s;
		
	}
	
 } 
 
 //打印链表数据 
 void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		//计数器
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		//每5个元素作为一行
		{
			printf("\n");
		}
	}
	printf("\n");

 }
 
 //在链表L中查找与e相等的元素，找到的话返回其位置， 否则返回未找到。 
 int searchElem(LNode *L, int e)
 {
 	LNode *temp = L;
 	int i = 1;
 	int p = 0;
 	while(temp ->next)
 	{
 		temp = temp ->next;
 		if(e == temp->data)
 		{
 			p = i;
 			printf("找到了与%d相等元素位置为%d\n",e,p);
 			return 1;
		}
		i++;
	 }
	 printf("抱歉，没有找到！");
	 return -1;
 }
 
 int main()
 {
 	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	}
	createlistF(L,a,n);
	printfList(L);
	
	//测试查找结点 
	int e;
	printf("请输入要查找的结点:");
	scanf("%d",&e);
	searchElem(L,e);
	
	
	return 0;
 }

5.4、修改结点

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

//单链表的结构定义 
typedef struct LNode
{
	int data;			//data存放结点数据域 
	struct LNode *next;	//指向后继结点的指针 
}LNode;					//定义单链表结点类型 


//头插法建立单链表
void createlistF(LNode *&L, int a[], int n)
{
	LNode *s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));
	L ->next = NULL;
	for(i=0;i<n;++i)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s ->data = a[i];
		s ->next = L ->next;
		L ->next = s;
		
	}
	
 } 
 
 //打印链表数据 
 void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		//计数器
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		//每5个元素作为一行
		{
			printf("\n");
		}
	}
	printf("\n");

 }

// 修改单链表L的第p个位置上的结点 
int replace(LNode *L, int p, int e)
{
	LNode *temp = L;
	temp = temp ->next;
	for(int i=1;i<p;++i)
	{
		temp = temp ->next;
	}
	temp ->data = e;
  }  
 

 
 int main()
 {
 	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	}
	createlistF(L,a,n);
	printfList(L);
	
	//测试修改结点 
	int p,e;
	printf("请输入要修改的位置和更改后的元素(用空格分开)：\n");
	scanf("%d %d",&p,&e);
	replace(L,p,e);
	
	//修改后打印链表数据 
	printfList(L); 
	
	return 0;
 }

5.5、插入结点

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

//单链表的结构定义 
typedef struct LNode
{
	int data;			//data存放结点数据域 
	struct LNode *next;	//指向后继结点的指针 
}LNode;					//定义单链表结点类型 


//头插法建立单链表
void createlistF(LNode *&L, int a[], int n)
{
	LNode *s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));
	L ->next = NULL;
	for(i=0;i<n;++i)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s ->data = a[i];
		s ->next = L ->next;
		L ->next = s;
		
	}
	
 } 
 
 //打印链表数据 
 void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		//计数器
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		//每5个元素作为一行
		{
			printf("\n");
		}
	}
	printf("\n");

 }
 
 //在链表L的第p个位置上插入元素e 
 void insertElem(LNode *L, int p, int e)
 {
 	LNode *temp = L;
 	int i = 0;
 	while(i<p-1)
 	{
 		temp = temp ->next;
 		++i;
	}
	LNode *s = (LNode*)malloc(sizeof(LNode)); //创建新结点 
	s ->data = e;
	s->next = temp ->next;
	temp ->next = s;
 }

 
 int main()
 {
 	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	}
	createlistF(L,a,n);
	printfList(L);
	
	//测试插入结点 
	int p,e;
	printf("请输入要插入的位置和要插入的元素(用空格分开)：\n");
	scanf("%d %d",&p,&e);
	insertElem(L,p,e);
	
	//插入后打印链表数据
	printfList(L); 
	
	return 0;
 }

5.6、删除结点

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

//单链表的结构定义 
typedef struct LNode
{
	int data;			//data存放结点数据域 
	struct LNode *next;	//指向后继结点的指针 
}LNode;					//定义单链表结点类型 


//头插法建立单链表
void createlistF(LNode *&L, int a[], int n)
{
	LNode *s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));
	L ->next = NULL;
	for(i=0;i<n;++i)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s ->data = a[i];
		s ->next = L ->next;
		L ->next = s;
		
	}
	
 } 
 
 //打印链表数据 
 void printfList(LNode *L)
 {
 	LNode *temp = L;
	int count = 0;		//计数器
	printf("表中的元素为:\n");
	while(temp->next)
	{
		temp = temp->next;
		printf("%d\t",temp->data);
		count++;
		if(count%5==0)		//每5个元素作为一行
		{
			printf("\n");
		}
	}
	printf("\n");

 }
 
 //删除单链表L中第p位置上的结点 
 void deleteElem(LNode *L, int p, int *e)
 {
 	LNode *temp = L;
 	int i = 0;
 	//找到删除结点的上一结点，即第p-1个结点
 	while(i<p-1)
 	{
 		temp = temp ->next;
 		++i;
	}
	LNode *q = temp->next;	//定义一个q指针指向被删除结点
	*e = q->data;			//保存被删除的结点的数据域
	temp->next = q->next;	//删除结点的上一个结点的指针域指向删除结点的下一个结点
  	free(q);				//释放q所指结点的内存空间 
  } 


 
 int main()
 {
 	LNode *L;
 	int n;
 	printf("请输入数组的个数："); 
 	scanf("%d",&n);
 	int a[n];
 	printf("请输入数组中的数(用空格分开)：\n");
 	for(int i=0;i<n;++i)
 	{
 		scanf("%d",&a[i]);
	}
	createlistF(L,a,n);
	printfList(L);
	
	//测试删除结点 
	int p,e;
	e = NULL;
	printf("请输入要删除结点的位置：\n");
	scanf("%d",&p);
	deleteElem(L,p,&e);
	
	//插入后打印链表数据
	printfList(L); 
	
	return 0;
 }

总结

以上就是今天要讲的内容，本文仅仅简单介绍了单链表的一些基本操作与创建方法，以及相关的特点，希望对你们有所帮助，也欢迎大佬的指正。

张小鱼༒
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码是：1234。代码仅供初学者学习和期末复习参考。
为什么单链表的插入和删除速度要比顺序表快
weixin_43715601的博客
02-16 3402
单链表与顺序表的问题探究 首先这是顺序表的插入和删除的代码: //在顺序表L的第i个位置插入元素e bool ListInsert(SqList &L,int i,ElemType e){ if(i < 1 || i > L.length + 1) //判断i的范围是否有效 return false; if(L.length >= MaxS...
单链表常见操作以及和顺序表的区别
qq_38158479的博客
09-26 742
单链表的定义： 二：和顺序表的区别 时间性能上： 查找:顺序存储结构O(1),单链表O(n) 插入和删除：顺序存储结构O(n),单链表O(1) 线性表的顺序存储结构和单链表结构各具有其优缺点，不能简单的说那个好，那个坏，需要根据实际情况。来综合平衡采用哪种数据结构更能满足和达到需求和性能。 //Linklist.cpp #include"Linklist.h" Link...
几分钟彻底了解单链表、带头链表、双向链表、循环链表、带头双向循环链表速通，知识解析与实现。
loneplayer的博客
05-18 502
图解如果都给Node1-Node3都附加上一个地址的话，那可以更加直观的理解链表的结构。所以next指向的是一个地址，而且还是结构体的地址。结构体为：}Node;应用方面：如队列的实现等，对于需要用到链表的时候都先优先考虑不带头节点的单链表，因为结构简单，满足需求就可以了。
计算机考研复试面试问答整理（计算机网络、数据结构、操作系统、数据库、热点概念）
热门推荐
xxxli_的博客
05-10 1万+
数据结构 1、顺序存储和链式存储优缺点比较 ① 顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。 优点：存储密度大（＝1），易于查找和修改。 缺点：插入或删除元素时不方便；存储空间利用率低，预先分配内存可能造成存储空间浪费。 ②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 优点：插入或删除元素时很方便，使用灵活，存储空间利用率高。 缺点：存储密度小（<1），查找和修改需要遍历整个链表
小甲鱼笔记：数据结构——线性表（二）线性表的链式存储结构，单链表，头指针与头结点的区别，单链表的增，删，插入元素操作以及效率问题
Mr_GYF的博客
03-08 615
一、线性表的链式存储结构 1.特点：线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。 链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的地址（指针）。也就是说除了存储本身信息外，还要存储一个指示其直接后继的存储位置的信息。 ...
（4）链表（单链表）
革命队伍的螺丝钉
10-28 532
链表：单链表 以链式结构存储结构的线性表称为线性链表。 元素本身的信息和其后期信息组成数据元素的存储映像，称为结点; 线性链表有三种： 1）单链表 2）双链表 3）循环链表。 对链表的任何操作都必须从第一个结点开始，第一个结点的地址存放在一个指针变量中，这个指针变量指向第一个结点， 也就是链表最前面的结点，因此这个指针变量常称为头指针。 我们在整个线性链表的第一个结点
数据结构：链表-笔记
世上再无张显宗
06-16 2826
1、在链表中进行操作比在顺序表中进行操作效率高 正确答案: D 你的答案: B (错误) 顺序查找 折半查找 分块查找 插入 2、在______运算中，使用顺序表比链表好 正确答案: C 你的答案: A (错误) 插入 删除 根据序号查找 根据元素值查找 3、在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（） 正确答案: D 你的答案: A (错误) s->next=p+1; p->next=s; (*p).next=s; (*s).next=(*p).next s-
Python中的顺序表
qq_41020281的博客
05-04 665
Python中的list和tuple两种类型采用了顺序表的实现技术，具有前面讨论的顺序表的所有性质。tuple是不可变类型，即不变的顺序表，因此不支持改变其内部状态的任何操作，而其他方面，则与list的性质类似。list的基本实现技术Python标准类型list就是一种元素个数可变的线性表，可以加入和删除元素，并在各种操作中维持已有元素的顺序（即保序），而且还具有以下行为特征：基于下标（位置）的高...
对于插入和删除数据越频繁的操作 ，单链表较顺序存储结构效率越有优势
李响
04-28 3101
单链表由好多个结点构成 其中头节点可有可无 可以用来存放链表长度。 头指针必须有 每一个指针指向 下一个结点的数据域 头指针指向头结点 头结点中还有一个指针变量 指针域是一个结点类型的指针 #include<iostream> using namespace std; typedef int ElementType; typedef int status; typedef stru...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——线性表(选择题).docx
07-11
数据结构——线性表（选择题） 1.线性表是（）。 简单，线性表的概念与性质，02702001 [单选题] A、一个有限序列，可以为空(正确答案) B、一个无限序列，不可以为空 C、一个无限序列，可以为空 D、一个无限序列，不...
链表基础知识（一、单链表、头插、尾插、头删、尾删、查找、删除、插入、求表长，合并链表）
最新发布
走在努力路上的自己的博客
12-13 2787
顺序表的问题及思考问题：1.中间/头部的插入删除，时间复杂度为O(N)2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面给出了链表的结构来看看。
C语言【数据结构】顺序表、链表【选择题】
冰果滴的博客
06-06 3555
目录 1. 在长度为 n 的顺序表下标为 i 的位置前插入一个元素（1 ≤ i ≤ n+1），元素的移动次数为（B）2.下列关于链表的说法哪个是正确的？（A）3.在单链表指针为p的结点之后插入指针为s的结点，正确的操作是（C）4.下列判断循环双向链表为空的语句中，正确的是（C）5. 在长度为n(n>1)的单链表上，设有头和尾两个指针，执行（D）操作与链表的长度有关。6.关于链表和顺序表间的区别，叙述错误的是（D）7.在一个循环双向链表中，要在p所指的节点之前插入s所指节点，以下代码正确的执行次序是（A）
C语言 顺序表与链表的知识总结与优缺点分析
GMfengyi的博客
12-20 560
本文讲解了顺序表，链表操作函数的实现方法以及两者的优缺点分析及应用场景等。
栈和队列都是限制存取点的线性结构_数据结构期末复习题及部分答案解析(1)
weixin_39634985的博客
12-01 1473
可以微信扫码观看河南城建0一．是非题1. 数据结构(应该是抽象数据类型)可用三元式表示(D，S，P)。其中：D是数据对象，S是D上的关系，P是对D的基本操作集。(f)2 简单地说,数据结构是带有结构的数据元素的集合。(t)3 判断带头结点的非空循环单链表(头指针为L)中指针p所指结点是最后一个元素结点的条件是：p->next==L。(t)4 线性表的链式存储结构具有可直接存取?表中...
单链表与顺序表的比较（优缺点）
weixin_42904113的博客
01-23 2750
6.若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用（）存储方式最节省时间。 正确答案: A A.顺序表B.双链表C.带头结点的双循环链表D.单循环链表笔记：单链表与顺序表的比较（优缺点）：顺序表，逻辑上相邻的元素其物理位置也一定相邻，顺序表是一种随机存储结构，对于表中每个结点都可以在O(1)时间内访问，但进行插入，删除时需要移动大量的元素，时间复杂度为O(n)。 ...
顺序表和单链表的异同
08-04
顺序表和单链表是两种常见的数据结构，它们有一些异同之处。 相同之处： 1. 都可以用来存储一组数据元素。 2. 都可以进行插入、删除和查找等操作。 异同之处： 1. 存储方式不同：顺序表使用连续的内存空间存储元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

张小鱼༒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值