线性表——顺序存储结构实现(顺序表)

1.顺序表基本知识

2. 顺序表基本操作（静态、动态）

1.顺序表：静态分配

#include<bits/stdc++.h>
using namespace std;

#define MaxSize 10		//顺序表最大长度 
typedef struct{
	int data[MaxSize];		//存储数组 
	int length;			//顺序表长度 
} SqList;		//别名 

//初始化顺序表 (长度为0)
void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		//初始化顺序表值为0 (这个操作有无均可，因为顺序表以内置length为长度)
		L.data[i]=0; 	
	}
	L.length=0;
} 

//创建顺序表（长度为len） 
void CreatList(SqList &L,int a[],int len){
	if(len>MaxSize){
		cout<<"超出数据表所给最大长度！！！"<<endl; 
	}
	else{
		for(int i=0;i<len;i++){		//将顺序表值初始化 
			L.data[i]=a[i];
		}
		L.length=len;		//初始化顺序表长度 
	} 
} 

//销毁顺序表
void DestroyList(){
	cout<<"静态存储分配，程序结束自动释放存储单元！"<<endl; 
} 

//打印顺序表元素 
void PrintList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.data[i]<<" ";
	}
}

//按值查找
int Locate(SqList L,int e){
	int flag=-1;
	for(int i=0;i<L.length;i++){
		if(e==L.data[i]){
			flag=i+1;	//返回顺序表中的位置 
		}
	}
	return flag; 
} 

//按位查找
int Get(SqList L,int i){
	if(i<1||i>L.length){
		cout<<"下标越界！"<<endl;
		return -1; 
	}
	else{
		return L.data[i-1];
	}
} 

//***重要*** 
//插入数据 !!! 这个比较重要 
int Insert(SqList &L,int i,int e){
	int flag=1;	//标记是否插入成功
	if(L.length==MaxSize){
		cout<<"上溢出!!"<<endl;
		flag=-1;
	}
	else if(i<1||i>L.length+1){
		cout<<"插入位置错误！"<<endl; 
		flag=-1;
	} 
	else{
		for(int j=L.length;j>=i;j--){
			L.data[j]=L.data[j-1];	//顺序后移 
		}
		L.data[i-1]=e;		//插入值 
		L.length++;		//顺序表长度+1 
	}
	return flag; 
} 

//删除(返回删除元素的值---使用引用将其带回)
int Delete(SqList &L,int i,int &e){
	int flag=1;		//标志是否删除成功
	if(i<1||i>L.length){
		flag=-1;
	} 
	else{
		e=L.data[i-1];		//记录要删除的值
		for(int j=i-1;j<L.length-1;j++) {
			L.data[j]=L.data[j+1];	//依次向前覆盖 
		}
		L.length--;		//顺序表长度-1 
	}
	return flag; 
}
 
//主程序 
int main(){
	
	SqList L;
	
	//1.测试 初始化和输出
//	 InitList(L);
//	 PrintList(L);
	
	//2.测试 创建顺序表和输出
	int a[]={2,5,8,3,6,9};
	CreatList(L,a,6);
//	PrintList(L);

	//3.测试 按值查找 (成功返回值的位置，失败返回 -1)
//	cout<<Locate(L,8)<<endl;
	 
	//4.测试 按位查找 (成功返回值，失败返回 -1)
//	cout<<Get(L,8)<<endl; 
	
	//5.测试 插入，打印 (成功返回1，失败返回 -1)
//	cout<<Insert(L,3,1)<<endl;
//	PrintList(L);
	
	//6.测试 删除，打印 (成功返回1，失败返回 -1)
	int e=-999999;	//存储删除的值 
	cout<<Delete(L,3,e)<<endl;
	PrintList(L); 
	
	return 0;
} 

2.顺序表：动态分配

#include<bits/stdc++.h>
using namespace std;

#define InitSize 10
typedef struct{
	int *data;		//指向动态存储地址快（动态分配） 
	int MaxSize;		//最大长度 
	int length;		//当前长度 
}SeqList; 

//初始化
InitList(SeqList &L){
	L.data=(int *)malloc(InitSize*sizeof(int));	//动态分配 
	L.length=0;
	L.MaxSize=InitSize;
} 

//动态增加顺序表长度 
AddCreatList(SeqList &L,int len){
	int *p=L.data;
	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));	//增加len长度
	for(int i=0;i<L.length;i++){
		L.data[i]=p[i];
	} 
	L.MaxSize=L.MaxSize+len;
	free(p);	//	释放p空间 
}

int main(){
	
	SeqList L; 
	
	//未动态增加顺序表长度
	InitList(L);
	cout<<L.MaxSize<<endl;
	 
	//动态增加顺序表长度
	AddCreatList(L,5);
	cout<<L.MaxSize<<endl;
	
	return 0;
}