第二章：线性表

最新推荐文章于 2022-07-11 14:45:30 发布
最新推荐文章于 2022-07-11 14:45:30 发布
阅读量355 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangduang1/article/details/118191888
版权

2.1线性表的定义和基本操作

2.1.1线性表的定义

线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。
位序： 从1开始，表示线性表中的第几个元素
下标： 从0开始
线性表中存在唯一的“第一个”数据元素，又称表头元素；唯一的“最后一个”数据元素，又称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。

2.1.2线性表的特点

  • 表中元素的个数有限
  • 表中元素具有逻辑上的顺序性，表中元素有其先后顺序
  • 表中元素都是数据元素，每个元素都是单个元素
  • 表中元素的数据类型都相同，这意味着每个元素占有相同大小的存储空间
  • 表中元素具有抽象性，即仅讨论元素间的逻辑关系，而不考虑元素究竟表示什么内容

注： 线性表是一种逻辑结构，即线性结构，表示元素之间一对一的相邻关系；顺序表和链表是指存储结构，即顺序存储和链式存储。

2.1.3线性表基本操作

  • InitList(&L)：初始化表，构造一个空表
  • DestroyList(&L)：销毁表，并释放线性表L所占用的内存空间
  • Length(L)：求表长，即L中数据元素的个数
  • LocateElem(L,e)：按值查找，在表L中查找具有给定关键字值的元素
  • GetElem(L,i)：按位查找，获取表L中第i个位置的元素的值
  • ListInsert(&L,i,e)：插入操作，在表L中的第i个位置插入指定元素e
  • ListDelete(&L,i,&e)：删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值
  • PrintList(L)：输出操作，按前后顺序输出线性表L中所有元素值
  • Empty(L)：判空操作，若L为空表，则返回true，否则返回false

注： ”&“表示C++语言中的引用调用，将操作结果“带回来 ”

void test(int x){
	x=1024;
	printf("test函数内部 x=%d\n",x);
}
int main(){
	int x=1;
	printf("调用test函数前 x=%d\n",x);
	test(x);
	printf("调用test函数后 x=%d\n",x);
}
/*
以上代码输出结果为：
调用test函数前 x=1
test函数内部 x=1024
调用test函数后 x=1
*/

//将test函数改为
void test(int &x){
	x=1024;
	printf("test函数内部 x=%d\n",x);
}
/*
以上代码输出结果为：
调用test函数前 x=1
test函数内部 x=1024
调用test函数后 x=1024
*/

//这就是&带回来效果

2.2线性表的顺序表示

2.2.1顺序表定义

线性表的顺序存储称为顺序表，它是一组地址连续 的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。

2.2.2顺序表特点

  • 逻辑顺序与物理顺序相同
  • 随机访问，即通过首地址和元素序号可在时间O(1)内找到指定的元素
  • 存储密度高，每个节点只存储数据元素
  • 拓展容量不方便
  • 插入删除操作不方便

2.2.3静态分配与动态分配

//静态分配
#define MaxSize 50     //定义线性表最大长度
typedef struct{
	ElemType data[MaxSize];//顺序表元素
	int length;//顺序表当前长度
}SqList;//顺序表类型定义
//静态分配示例：
#define MaxSize 10     //定义最大长度
typedef struct{
	int data[MaxSize];//用静态的“数组”存放数据元素
	int length;//顺序表当前长度
}SqList;//顺序表类型定义
void InitList(SqList &L){//初始化一个顺序表
	for(int i=0;i<MaxSize;i++){
		L.data[i]=0;//将所有元素设置默认初始值，消除脏数据，可省略，因为相关操作都与length有关
		L.length=0;//顺序表初始长度为0
	}
}
int main(){
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	//...相关操作
	return 0;
}



//动态分配
#define InitSize 100    //表长度的初始定义
typedef struct{
	ElemType *data;//指示动态分配数组的指针
	int MaxSize,length;//数组最大容量和当前个数
}SeqList;//动态分配数组顺序表的类型定义
//动态分配示例：
#define InitSize 10    //默认最大长度
typedef struct{
	int *data;//指示动态分配数组的指针
	int MaxSize,length;//数组最大容量和当前个数
}SeqList;//动态分配数组顺序表的类型定义
void InitList(SeqList &L){//初始化
	//用malloc函数申请一片连续存储空间
	L.data=(int *)malloc(InitSize*sizeof(int));//申请空间类型强制转换为与顺序表数组类型一致
	L.length=0;
	L.MaxSize=InitSize;
}
void IncreaseSize(SeqList &L,int len){//动态增加数组长度
	int *q=L.data;
	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
	for(int i=0;i<L.length;i++){
		L.data[i]=p[i];//将数据复制到新区域
	}
	L.MaxSize=L.MaxSize+len;//顺序表最大长度增加len
	free(p);//释放原来空间
}
int main(){
	SeqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	//...增加元素
	IncreaseSize(L,5);//扩展数组长度
	return 0;
}

2.3顺序表基本操作的实现

2.3.1插入

在顺序表L的第i(1<=i<=L.length+1)个位置插入新元素e。若i输入不合法，则返回false，表示插入失败；否则，将第i个元素及其后的所有元素依次往后移一个位置，腾出一个空位置插入新元素e，顺序表长度增加1，插入成功，返回true。

bool ListInsert(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1)//判断i范围是否有效
		return false;
	if(L.length>=MaxSize)//当存储空间已满，不能插入
		return false;
	for(int j=L.length;j>=i;j--)//将第i个及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=e;//在位置i放入e
	L.length++;//线性表长度加1
	return true;
}

注： 区别位序和数组下标，时间复杂度：

  • 最好情况：在表尾插入（即i=n+1），元素后移语句不再执行，时间复杂度为O(1)；
  • 最坏情况：在表头插入（即i=1），元素后移语句将执行n次，时间复杂度为O(n)；
  • 平均情况：O(n)。

2.3.2删除

删除顺序表L中第i(1<=i<=L.length)个位置的元素，用引用变量e返回。若i不合法，则返回false；否则将被删元素赋给引用变量e，并将第i+1个元素及其后的所有元素往前移动一个位置，返回true。

bool ListDelete(SqList &L,int i,ElemType &e){
	if(i<1||i>L.length)//判断i的范围是否有效
		return false;
	e=L.data[i-1];//将被删除的值赋给e
	for(int j=1;j<L.length;j++)//将第i个位置后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;//线性表长度减1
	return true;
}

注： 区别位序和数组下标，时间复杂度：

  • 最好情况：删除表尾元素（即i=n），无需移动元素，时间复杂度为O(1)；
  • 最坏情况：删除表头元素（即i=1），需移动除表头元素外的所有元素，时间复杂度为O(n)；
  • 平均情况：O(n)。

2.3.3查找

//按位查找：
ElemType GetElem(SqList L,int i){//i表示位序
	return L.data[i-1];//返回数值，静态动态存储都一样
}
//时间复杂度O(1)


//按值查找：
int LocateElem(SqList L,ElemType e){//在顺序表中查找第一个元素值等于e的元素，并返回其位序
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;//下标为i的元素值等于e，返回其位序i+1
	return 0;//退出循环，查找失败
}
/*
时间复杂度：
最好情况：查找元素在表头，仅比较一次，时间复杂度为O(1)
最坏情况：查找元素在表尾，需比较n次，时间复杂度为O(n)
平均情况：O(n)
*/

2.4线性表的链式表示

2.4.1单链表的定义

线性表的链式存储又称单链表 ，它是指通过一组任意的存储单元来存储线性表中的数据元素

单链表特点：

  • 不需要大块存储单元
  • 附加指针，存在浪费存储空间的缺点
  • 非随机存取，查找特定结点需从头开始遍历
typedef struct LNode{//定义单链表结点类型
	ElemType data;//数据域
	struct LNode *next;//指针域
}LNode, *LinkList;//别名
/*
LNode * L：强调这是一个结点
LinkList L：强调这是一个单链表
*/


//不带头结点的单链表初始化：
bool InitList(LinkList &L){
	L=NULL;//置空，防止存在脏数据
	return true;
}
//判断单链表是否为空：
bool Empty(LinkList L){
	return (L==NULL);
}

//带头结点的单链表初始化：
bool InitList(LinkList &L){
	L=(LNode *)malloc(sizeof(LNode));//分配一个头结点
	if(L==NULL)//内存不足，分配失败
		return false;
	L->next=NULL;//头结点之后置空
	return true;
}
//判断单链表是否为空：
bool Empty(LinkList L){
	return (L->next==NULL);
}
/*
带头结点，写代码更方便；
不带头结点，写代码更麻烦：
对第一个数据结点和后续数据结点的处理需要用不同的代码逻辑
对空表和非空表的处理需要用不同的代码逻辑
*/

2.4.2单链表插入删除操作

//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)//无效结点
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));//申请一个结点
	if(s==NULL)//因为内部原因，申请失败，发生可能极小
		return false;
	s->data=e;//元素e保存至s结点中
	s->next=p->next;//s的指针域指向p的指针域，即将p之后结点连接到s后
	p->next=s;//将结点s连接到p之后
	return true;
}
//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p,ElemType e){
	if(p==NULL)//无效结点
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));//申请一个结点
	if(s==NULL)//因为内部原因，申请失败，发生可能极小
		return false;
	//偷天换日：
	s->next=p->next;//将p之后结点连接在s上
	p->next=s;//将s连接在p上
	s->data=p->data;//将p中元素复制到s中
	p->data=e;//e覆盖p中元素
}
/*
时间复杂度O(1)
*/

//按位序插入：在带头结点的单链表L中的第i个位置插入元素e
bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)//非法位序
		return false;
	LNode *p;//指针p当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p=L;//扫描开始位置，L指向头结点，头结点是第0个节点，不存数据
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	return InsertNextNode(p,e);//当前p扫描到第i-1个位置，执行后插法
}
/*
最好时间复杂度：O(1)，插在表头，即i=1
最坏时间复杂度：O(n)，插在表尾，i=n
平均时间复杂度：O(n)
*/
//按位序插入：在不带头结点的单链表L中的第i个位置插入元素e
bool ListInsert(LinkList &L,int i,ElemType 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;//指针p当前扫描到的结点
	int j=1;//当前p指向的是第几个结点
	p=L;//扫描开始位置，L指向头结点，头结点是第0个节点，不存数据
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	return InsertNextNode(p,e);//当前p扫描到第i-1个位置，执行后插法
}


//按位序删除：删除带头结点的单链表L的第i个元素并返回删除元素e
bool ListDelete(LinkList &L,int i,ElemType e){
	if(i<1)//非法位序
		return false;
	LNode *p;//指针p当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p=L;//扫描开始位置，L指向头结点，头结点是第0个节点，不存数据
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL)//无效结点，i值不合法
		return false;
	if(p->next==NULL)//第i-1结点后以无其他结点
		return false;
	LNode *q=p->next;//令q指向被删结点
	e=q->data;//用e返回元素的值
	p->next=q->next;//将*q结点从链中断开
	free(q);//释放结点的存储空间
	return true;//删除成功
}

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

2.4.3单链表查找与求表长操作

//查找带头结点的单链表L的第i个元素（按位查找）
LNode * GetElem(LinkList L,int i){
	if(i<0)
		return NULL;
	LNode *p;//指针p当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p=L;//扫描开始位置，L指向头结点，头结点是第0个节点，不存数据
	while(p!=NULL && j<i){//循环找到第i个结点
		p=p->next;
		j++;
	}
	return p;
}
/*
平均时间复杂度O(n)
*/
//拓展：改写插入操作
//按位序插入：在带头结点的单链表L中的第i个位置插入元素e
bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)//非法位序
		return false;
	LNode *p = GetElem(L,i-1);
	return InsertNextNode(p,e);//当前p扫描到第i-1个位置，执行后插法
}
/*
封装的好处：避免重复代码，简洁易维护
*/

//查找带头结点的单链表L的的数据域为e的结点（按值查找）
LNode * LocateElem(LinkList L,ElemType e){
	LNode *p=L->next;
	//从第一个结点开始查找数据域为e的结点
	while(p!=NULL && p->data!=e)
		p=p->next;
	return p;//找到后返回该结点指针，否则返回NULL（没找到就已经指向了NULL）
}

//求表的长度
int Length(LinkList L){
	int len=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}
	return len;
}

2.4.4单链表的建立

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
	int x;//设数据域为整型
	InitList(L);//初始化带头结点单链表
	LNode *s,*r=L;//r为表尾指针
	scanf("插入数据：%d",&x);
	while(x!=0000){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		//以上三行代码等价于：InsertNextNode(r,x);//后插操作，内有*s
		r=s;//r指向新的表尾结点
		scanf("插入数据：%d",&x);
	}
	r->next=NULL;//表尾结点指针置空
	return L;
}
/*
时间复杂度：O(n)
*/
//尾插法笨方法，时间复杂度O(n^2)
LinkList list_TailInsert_II(LinkList &L){
	InitList(L);//初始化带头结点单链表
	int x,length=0;//数据域设为整型，长度初始化
	scanf("插入数据：%d",&x);
	while(x!=0000){
		ListInsert(L,length+1,x);//按位序插入：在带头结点的单链表L中的第length+1个位置插入元素x
		length++;
		scanf("插入数据：%d",&x);
	}
	return L;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
	int x;
	InitList(L);//初始化
	scanf("插入数据：%d",&x);
	while(x!=0000){
		InsertNextNode(L,x);//后插操作，头结点后插入x
		scanf("插入数据：%d",&x);
	}
	return L;
}
/*
时间复杂度O(n)
*/

2.4.5双链表

双链表结点中有两个指针prior和next，分别指向其前驱结点和后继结点。

//双链表结点类型描述
typedef struct DNode{//D:double
	ElemType data;//数据域
	struct DNode *prior,*next;//前驱和后继指针
}DNode,*DLinkList;

//初始化双链表（带头结点）
bool InitDLinkList(DLinkList &L){
	L=(DNode *)malloc(sizeof(DNode));//分配一个头结点
	if(L==NULL)//内存不足，分配失败
		return false;
	L->prior=NULL;//头结点的prior永远指向NULL
	L->next=NULL;//头结点之后暂时还没有结点
	return true;
}

//判断双链表是否为空（带头结点）
bool Empty(DLinkList L){
	if(L->next==NULL)
		return true;
	else
		return false;
}

//双链表的插入：在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s){
	if(p==NULL || s==NULL)
		return false;
	s->next=p->next;
	if(p->next!=NULL)
		p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
}

//双链表删除：删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
	if(p==NULL)	return false;
	DNode *q=p->next;//找到p的后继结点
	if(q==NULL)	return false;//p没有后继
	p->next=q->next;
	if(q->next!=NULL)//q结点不是最后一个结点
		q->next->prior=p;
	free(q);//释放q
	return true;
}
//双链表的销毁
void DestoryList(DLinkList &L){
	//循环释放头结点的后继结点
	while(L->next!=NULL)
		DeleteNextDNode(L);
	free(L);//释放头结点
	L=NULL;//头指针指向NULL
}
/*
双链表不可随机存取，按位查找、按值查找都只能用遍历的方式实现，时间复杂度O(n)
*/

2.4.6其他链表

  • 循环单链表：最后一个结点指针指向头结点
  • 循环双链表：头结点prior指针指向尾结点；尾结点next指针指向头结点
  • 静态链表：数组

2.5顺序表和链表的比较

  1. 存取方式
    顺序表：顺序存取和随机存取
    链表：顺序存取
  2. 逻辑结构与物理结构
    顺序表：逻辑上相邻，物理上也相邻
    链表：物理不相邻，逻辑关系用指针链接
  3. 查找、插入和是删除操作
    顺序表：无序按值查找O(n)，有序按值查找O(log2n)；按位查找O(1)；插入删除需要移动大量元素
    链表：按值查找O(n)；按位查找O(n)；插入删除只需要修改相关指针
  4. 空间分配
    顺序表：静态存储空间不可扩充，动态操作麻烦
    链表：操作灵活高效
终究成为社畜
关注
专栏目录
【数据结构知识点总结】二、线性表
叶柖的博客
10-08 791
线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，n为表长，当n=0时该线性表是一个空表。 逻辑特性：除表头元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。 线性表基本操作的实现取决于采用哪种存储结构。 线性表的顺序表示 线性表的顺序存储又称顺序表。 线性表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。 线性表的数据类型描述： #def...
王道2023数据结构笔记
一顿吃不饱的博客
07-15 1万+
线性表的定义​线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=(a1,a2,…,ai,ai+1,…,an)​ai是线性表中的“第i个”元素线性表中的位序​a1是表头元素；an是表尾元素​除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继线性表的基本操作初始化表。构造一个空的线性表L，分配内存空间。销毁操作。插入操作。删除操作。...
数据结构复习之线性表（1）
weixin_52270376的博客
07-11 379
线性表特点：1.存在唯一的第一个和最后一个的数据元素 2.除第一个元素外，每个元素只有一个前驱，除最后一个元素外每一个元素只有一个后继简单来说，线性表就像一个宽度只有一个元素的长条一样，用来储存数据。首先我们先来了解一下顺序表。顺序表定义：顺序表是用一组地址连续的存储空间依次存储线性表的数据元素。顺序表的特点：1.各个数据元素的逻辑顺序与其存放的物理顺序一致2.对于顺序表中的所有元素，既可以进行顺序依次访问，也可以进行随机直接访问3.顺序表用一维数组实现时，存储空间可以是静态分配的，也可以是动态分配的4.顺
数据结构-线性表的顺序、链式存储结构
qq_61167424的博客
03-21 4839
一篇文章带你了解线性表的顺序、链式存储结构
数据结构之 线性表
TomotoJ的博客
03-25 629
线性结构的特点： 在数据元素的非空有限集合中 1、存在唯一一个被称为“第一个”的数据元素， 2、存在唯一一个被称作“最后一个”的数据元素， 3、除第一个之外，集合中的每一个数据元素均只有一个前驱， 4、除最后一个之外，集合中的每一个数据元素均只有一个后继线性表：是n个数据元素的有限序列。 线性表的顺序表示： 用一组地址连续的存储单元依次存储线性表的数据元素。 用数组实现具体参照jdk
数据结构——线性结构
ZXlxilin
11-25 3267
数据结构——线性结构 一、线性结构 在学习线性表之前肯定是需要对线性结构进行理解，如果按我个人的经验来说的话对于线性结构的理解是在学习数据结构中最为重要的，几乎后面所有学习结构都或多或少对线性结构进行利用。 线性结构 特点 前提 在数据结构的非空有限集合中 1 存在唯一的一个被称做“第一个”的元素 2 存在唯一的一个被称做“最后一个”的数据元素 3 除最后元素之外，其它...
第二章：线性表-21
08-03
4. 环形链表：环形链表与普通链表的区别在于最后一个结点的指针不为null，而是指向链表的第一个结点，形成一个循环。这使得遍历链表可以持续进行，而无需检查是否到达链表末尾。 在实际应用中，这些线性表的实现...
第二章：线性表-11
08-03
线性表是计算机科学中一种基础且重要的数据结构，它由n个（n>=0）相同类型元素构成的有序集合。...通过学习这一章，学生应能够熟练地运用线性表解决实际问题，并具备比较和选择合适存储结构的能力。
第二章：线性表-41
08-03
线性表是计算机科学中一种基础且重要的数据结构，它是由相同类型元素组成的有序序列。在本章节中，我们主要探讨了三个与线性表相关的主题：表达式求解、队列以及串。 1. **表达式求解**： 在计算机科学中，表达式...
第二章：线性表-31
08-03
此外，环形链表和双向环形链表是线性链表的变体，它们的最后一个节点指向第一个节点，形成一个循环结构，这样的设计在处理循环数据时特别有用。 栈是一种特殊的数据结构，遵循“后进先出”（LIFO）原则。栈主要有两...
数据结构 第二章 线性表(1)
weixin_62917800的博客
04-04 3432
目录 2.1 线性表的定义和特点 2.2 案例引入 2.3 线性表的类型定义 2.4 线性表的顺序表示和实现 2.4.1线性表的顺序存储表示 2.4.2 顺序表中基本操作的实现 线性结构的基本特点是除第一个元素无直接前驱，最后一个元素无直接后继之外，其他每个数据元素都有一个前驱和后继。线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础，尤其单链表，是贯穿整个数据结构课程的基本技术。本章将讨论线性表的逻辑结构、存储结构和相关运算，以及线性...
数据结构系列-线性表（顺序表和链表）
weixin_52199109的博客
05-01 1709
线性表的定义和特点 线性结构的基本特点：除第一个元素无直接前驱，最后一个元素无直接后继，其他元素都有一个前驱和一个后继。 说人话就是：第一个元素不能向前访问，最后一个元素不能向后访问，中间的元素都可以前后访问其他元素。 例如：26个字母表{A,B,C,D,E,F…}就是一个线性表. 虽然该线性表中数据元素各不相同，但每个元素都具有相同的特性，都属于同一数据对象 线性表：由有限个数据特性相同的数据元素构成的***有限序列*** 如果没有数据元素，该线性表也叫空表。 ...
数据结构-线性表 1.简介
u014354882的博客
11-10 327
线性表(List) 定义及特点： 1、存在唯一的第一个元素；（这一点决定了图不是线性表） 2、存在唯一的最后一个元素； 3、除第一个元素外，其它均只有一个前驱（这一点决定了树不是线性表） 4、除最后一个元素外，其它均只有一个后继。 a1是a2的前驱，ai+1 是ai的后继，a1没有前驱，an没有后继 n为线性表的长度 ，若n==0时，线性表为空表 特点是1：1 其他线性表 一、顺序存储方式线性表（java中典型的：ArrayList就是顺序线性表） 存储位置连续，可以很方便
超清晰-数据结构之线性表
热门推荐
MClink的博客
05-25 3万+
鸟哥说，坚持学习基础才能有出人头地的一天。不能只专注于练武功了，内功也得练。 本篇文章是讲数据结构的第一篇，跟着书好好再过一篇基础。 一、线性表 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 对于非空的线性表或者线性结构的特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）...
线性表（一）——线性表概述
weixin_43328054的博客
02-08 297
基本概念 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素。 后继元素： 若B元素在A元素的后面，则称B为A的后继元素。 线性表特征 数据元素之间具有一种“一对一”的逻辑关系 1.第一个数据元素没有前驱，这个数据元素被称为头结点； 2.最后一个数据元素没有后继，这个元素被称为尾结点； 3.除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和后继。 线性表的分类 线性表中数据存储的方式是顺序
数据结构与算法——线性表、顺序表、链表、栈、队列
usunshineboy的博客
01-13 483
一、线性表 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素。 后继元素：若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种一对一的逻辑关系。 1.第一个数据元素没有前驱，这个数据元素被称为头结点； 2.最后一个数据元素没有后继，这个数据元素被称为尾结点； 3.除了第一个元素和最后一个元素外，其他数据元素有且仅有一个前驱和一个后继。 线性表的分类：线性表中数据元素存储的方式可以是顺序存储，也可以是链式存储，按照不同的存储方式可分为顺序表和链表。 1.1顺序表 1.1.1顺
线性表概念_线性表的顺序表表示和实现_线性表的顺序存储
diviner_s的博客
01-15 4949
线性表基础概念，线性表的顺序表表示和实现 线性表 线性表（linear list）是最基本、最简单、也是最常用的一种数据结构。线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 特征 线性表是具有相同特征的数据元素的一个有限序列。 线性表（linear list）由n（n>=0）个数据元素（结点）a1，a2，…，an组成的有限序列 线性表中元素的个数n（n...
《数据结构》第六篇、线性表概述（第一个数据结构，也是最简单的数据结构）
JerryWu145的专栏
04-13 388
玩命快递.jpg前面5篇文章我们讲解了数据结构和算法的一些概述，我们应该对数据结构和算法有了一定的认识了，本篇文章将会带着大家学习最简单的一个数据结构，即如题所述：线性表线性表，顾名思义是像线一样性质的表，他的用处多不胜数，是常用且最简单的一种数据结构。例如，一串英文字母，一队手拉手的小朋友，一份学生成绩单等都可以用线性表来表示。线性表的存储结构有顺序存储链式存储两种，本文章先介绍线性表的一些特性...
数据结构第二章：线性表详解
本PPT详细讲解了计算机科学与技术专业中的核心课程——数据结构的第二章内容，即线性表。线性表是一种基本且重要的数据结构，它由一个有序的数据元素集合组成，每个元素在集合中都有唯一的前后关系。 线性表的四个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

终究成为社畜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值