数据结构——顺序表

阿瞒啊

已于 2024-07-13 21:45:59 修改

阅读量224

点赞数 15

分类专栏：数据结构笔记文章标签：数据结构考研笔记

于 2024-05-18 21:40:37 首次发布

本文链接：https://blog.csdn.net/sy20021128/article/details/139031408

版权

数据结构笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

目录

定义

顺序表——用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

设线性表第一个元素的存放位置是LOC(L),LOC是location的缩写。那么第i个元素的存放位置为 LOC(L)+ (i - 1) * 数据元素的大小。

C语言取数据元素大小：sizeof(ElemType);ElemType是顺序表中存放数据元素的类型。例如：sizeof(int) = 4B;

优点：可随机存取，存储密度高

缺点：要求大片连续空间，改变容量不方便

顺序表的实现——静态分配

#define MaxSize 10    		 //定义最大长度
typedef struct{
	ElemType data[MaxSize]; //用静态的“数组” 存放数据元素 
	int length;				//顺序表的当前长度 
}SqList; 					//顺序表的类型定义（静态分配方式）

下列中数据元素的类型（ElemType）是 int。

#include<stdio.h>
#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;		//将所有数据元素设置为默认初始值 
	L.length = 0;			//顺序表初始长度为0 
} 

int main(){
	SqList L;				//声明一个顺序表 
	InitList(L); 			//初始化顺序表 
	
	//“违规”打印data数组
	//for(int i =0;i<MaxSize;i++){
	//	printf("data[%d] = %d\n" , i, L.data[i]);
	//} 
	
	//正确打印data数组
	for(int i =0;i<L.length;i++){
		printf("data[%d] = %d\n" , i, L.data[i]);
	} 
	return 0; 
}

①在内存中分配存储顺序表L的空间。包括MaxSize*sizeof(ElemType)和存储length的空间。

②把各个数据元素的值设为默认值（可省略）。如不设为默认值，内存中有遗留的“脏数据”会有影响。

③将Length的值设为0（不可省略）。

顺序表的实现——动态分配

#define InitSize 10    		//顺序表的初始长度 
typedef struct{
	ElemType *data; 		//指示动态分配数组的指针 
	int MaxSize;			//顺序表的最大容量 
	int length;				//顺序表的当前长度 
}SqList; 					//顺序表的类型定义（动态分配方式）

c语言：malloc （动态申请内存空间）、free（动态释放内存空间）；

malloc 函数返回一个指针，需要强制转型定义的数据元素类型指针。

	L.data = (ElemType *)malloc(sizeof(ElemType) * InitSIze);

c++：new（动态申请内存空间）、delete（动态释放内存空间）；

#include<stdlib.h>
#define InitSize 10    			//顺序表的初始长度 
typedef struct{
	int *data; 					//指示动态分配数组的指针 
	int MaxSize;				//顺序表的最大容量 
	int length;					//顺序表的当前长度 
}SeqList; 						//顺序表的类型定义（动态分配方式） 

//基本操作——初始化一个顺序表
void InitList(SeqList &L){
	//用 malloc函数申请一片连续的存储空间 
	L.data = (int *)malloc(InitSize*sizeof(int)); 
	L.length = 0;				//顺序表初始长度为0 
	L.MaxSize = InitSize;
} 

//增加动态数组的长度
void IncreaseSize(SeqList &L, int len){
	int *p = 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; 
}

顺序表的特点

①随机访问，即可以在O(1)时间内找到第i个元素。

②存储密度高，每个节点只存储数据元素。

③拓展容量不方便(即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高)

④插入、删除操作不方便，需要移动大量元素

顺序表的插入(ListInsert)

ListInsert(&L,i,e):插入操作。在表L中的第i个位置（位序）上插入指定元素e。

插入位置之后的元素都要后移

#include<stdio.h>

#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;		//将所有数据元素设置为默认初始值 
	L.length = 0;			//顺序表初始长度为0 
} 

void ListInsert(SqList &L,int i,int e){
	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 
}
 
int main(){
	SqList L;				//声明一个顺序表 
	InitList(L); 			//初始化顺序表 
	//...此处省略一些代码，插入几个元素 
	ListInsert(L,3,3);
	return 0; 
}

健壮性代码

bool ListInsert(SqList &L,int i,int 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;
}

最好时间复杂度：O(1)

最坏时间复杂度：O(n)

平均循环次数： $[n+(n-1)+(n-2)+......+1]\frac{1}{n+1}=\frac{n(n+1)}{2(n+1)}=\frac{n}{2}$

平均时间复杂度：O(n)

顺序表的删除(ListDelete)

删除位置之后的元素都要前移

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

#include<stdio.h>
 
#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;		//将所有数据元素设置为默认初始值 
	L.length = 0;			//顺序表初始长度为0 
} 
 
bool ListDelete(SqList &L,int i,int &e){
	if(i<1||i>L.length)				//判断i的范围是否有效 
		return false;
	e = L.data[i-1];				//将被删除的元素赋值给e 
	for(int j=i;j<L.length;j++)		//将第i个元素及以后的元素前移 
		L.data[j-1]= L.data[j];		
	L.length--; 					//长度减一 
	return true;
}
 
int main(){
	SqList L;				//声明一个顺序表 
	InitList(L); 			//初始化顺序表 
	//...此处省略一些代码，插入几个元素 
	int e = -1;  			//用变量e把删除元素“带回来” 
	if(ListDelete(L,3,e))
		printf("已删除第三个元素，删除元素值为=%d\n",e);
	else
		printf("位序i不合法，删除失败\n");
	return 0; 
}

最好时间复杂度：O(1)

最坏时间复杂度：O(n)

平均循环次数： $[(n-1)+(n-2)+......+1+0]\frac{1}{n}=\frac{n(n-1)}{2}\frac{1}{n}=\frac{n-1}{2}$

平均时间复杂度：O(n)

顺序表的按位查找(GetElem)

静态分配方式和动态分配方式一样

#define MaxSize 10    		 //定义最大长度
typedef struct{
	int data[MaxSize]; 		//用静态的“数组” 存放数据元素 
	int length;				//顺序表的当前长度 
}SqList; 					//顺序表的类型定义（静态分配方式） 
 
int GetElem(SqList L, int i){
	return L.data[i-1];
}

#define InitSize 10    		//顺序表的初始长度 
typedef struct{
	ElemType *data; 		//指示动态分配数组的指针 
	int MaxSize;			//顺序表的最大容量 
	int length;				//顺序表的当前长度 
}SqList; 					//顺序表的类型定义（动态分配方式）

 
int GetElem(SqList L, int i){
	return L.data[i-1];
}

时间复杂度：O(1)

顺序表的按值查找(LocateElem)

#define InitSize 10    		//顺序表的初始长度 
typedef struct{
	ElemType *data; 		//指示动态分配数组的指针 
	int MaxSize;			//顺序表的最大容量 
	int length;				//顺序表的当前长度 
}SqList; 					//顺序表的类型定义（动态分配方式）

//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList L, int 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)

最坏时间复杂度：O(n)

平均循环次数： $[n+(n-1)+(n-2)+......+1]\frac{1}{n}=\frac{n(n+1)}{2}\frac{1}{n}=\frac{n+1}{2}$

平均时间复杂度：O(n)

阿瞒啊

关注

15
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
数据结构——顺序表

顺序表——用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。设线性表第一个元素的存放位置是LOC(L),LOC是location的缩写。那么第i个元素的存放位置为 LOC(L)+ (i - 1) *数据元素的大小。C语言取数据元素大小：sizeof(ElemType);ElemType是顺序表中存放数据元素的类型。例如：sizeof(int) = 4B;
复制链接

扫一扫