线性表-顺序表的定义-01

1.线性表的定义

&:对参数的修改需要带回来

(1)对参数的修改没有带回来,可以理解为在内存中复制了一块空间,原地址依据存放x=1,复制的地址空间存放x=1024。

#include<stdio.h>
 
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

（2）对参数的修改带回来，直接在x的内存空间上修改需的值。

#include<stdio.h>
 
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=1024

2.顺序表的定义

（1）静态分配：给各个数据元素分配连续的存储空间，存储空间是静态的不可变。

局限性：顺序表的大小容量不可调

L.data[i]=0;    //将所有数据元素设置为默认初始值。若省略，则内存中遗留的脏数据会导致输出有误。

#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);
	for(int i=0;i<MaxSize;i++)//MaxSize可换为L.length，但最好的是使用基本操作
		printf("data[%d]=%d\n",i,L.data[i]);
	return 0;
} 

data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0

（2）动态分配

关键点：malloc、free

#include<stdio.h>
#define InitSize 10	//默认的最大长度
typedef struct{
	int *data;		//指示动态分配数组的指针
	int MaxSize;	//顺序表的最大容量 
	int length; 	//顺序表的当前长度
}SqList;			//顺序表的类型定义
//内存中开辟出一整片连续的存储空间 

//基本操作-初始化一个顺序表
void InitList(SqList &L){
	//用malloc函数申请一片连续的存储空间 ,返回一个指针,值赋给data ,data指向存储空间 
	L.data[i]=(int *)malloc(InitSize*sizeof(int));	
	L.length=0;		//顺序表初始长度为0
	L.MaxSize=InitSize ;
}
//增加动态数组的长度
void IncreaseSize(SqList $L,int len){
	int *p=L.data;
	//申请新的存储空间 
	L.data[i]=(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(){
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表 
	//插入数据 
	IncreaseSize(L,5);
	return 0;
} 

3.顺序表的操作

#include<iostream>
#include<string>
using namespace std; 
//顺序表的描述 
typedef int ElemType;	//线性表中存放的元素类型 
typedef struct
{
	ElemType *data;
	int size;		//数组空间大小 
	int length;		//线性表长度 
 } SqList;
bool InitList(SqList &L,int s=10);		//初始化顺序表,s分配的存储空间 
int  ListLength(const SqList &L);		//求线性表长度 ,不改变顺序表内容定义const  
int Locate(const SqList &L,const ElemType &e);	//按值查找 
bool GetDate(const SqList &L,int i,ElemType &e); 	//获得第 i个元素
bool InsList(SqList &L,int i,const ElemType &e); //在第i个元素前插入一个元素
bool DelList(SqList &L,int i,ElemType &e); 		//删除第i个元素
void DestroyList(SqList &L);					//销毁顺序表
void clearList(SqList &L);						//清空顺序表
bool EmptyList(const SqList &L);				//判断表是否为空表
void DispList(const SqList &L);					//遍历顺序表,即输出表中所有的元素
int main(){
	SqList L;
	InitList(L,2);
//	cout<<ListLength(L);
	for(int i=1;i<=5;i++)
		InsList(L,i,i+1);
	DispList(L);
	return 0;
	
} 
bool InitList(SqList &L,int s)			//初始化顺序表,s分配的存储空间 
{
	if(s<=0) s=10;
	L.data=new ElemType[s];
	if(L.data = NULL) return false;
	
	L.size=s;
	L.length=0;
}
int  ListLength(const SqList &L)		//求线性表长度 ,不改变顺序表内容定义const  
{
	return L.length;
}
int Locate(const SqList &L,const ElemType &e)	//按值查找 
{
	for(int i=0;i<L.length;i++)
	{
		if(L.data[i]==e)
			return i+1;
		else 
			return -1;
	 } 
}


bool GetDate(const SqList &L,int i,ElemType &e) 	//获得第 i个元素
{
	if(i>=1&&i<=L.length) 
	{
		e=L.data[i-1];
		return true; 
	}
	return false; 
}
bool InsList(SqList &L,int i,const ElemType &e)//在第i个元素前插入一个元素
{
	if(i<1||i>L.length+1)
		return false;
	if(L.size=L.length)
	{
		ElemType *temp =new ElemType[2*L.size];//进行扩容
		if(temp==NULL) return false;//扩容失败
		for(int i=0;i<L.length;i++)
		{
			temp[i]=L.data[i];//扩容成功,复制数组元素 
		}
		delete [] L.data;
		L.data=temp;
		L.size=L.size*2; 
	}
	for(int j=L.length-1;j>=i-1;j--)
	{
		L.data[j+1]=L.data[j];
		
	 } 
	L.data[i-1]=e;
	L.length++;
	
	return true;
}
bool DelList(SqList &L,int i,ElemType &e) 		//删除第i个元素
{
	if(i<1||i>L.length)
		return false;
	else
		e=L.data[i-1];
		for(int j=i;j<L.length;j++){
			L.data[j-1]=L.data[j];
		}
		L.length--;
		return true; 
}


void DestroyList(SqList &L)					//销毁顺序表
{
	delete [] L.data;
	L.data=NULL;//起始位置的值变为空指针 
	L.size=0;
	L.length=0;
}
void clearList(SqList &L)						//清空顺序表
{
	L.length=0;
}
bool EmptyList(const SqList &L)				//判断表是否为空表
{
	if(L.length==0) return true;
	else return false;
	
}
//&L引用参数,对实参的别名,不会有传参赋值,顺序表不发生变化时可以使用const 
void DispList(const SqList &L)				//遍历顺序表,即输出表中所有的元素
{
	for(int i=0;i<L.length;i++)
		cout<<L.data[i]<<" "; 
}