顺序表基本操作的代码实现

顺序表基本操作的代码实现

初始化

静态分配方式

#include 
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 

/**
* 初始化函数 
*
* @param L 顺序表指针 
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}


int main(){
	SqList L;
	InitList(L);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	printf("length=%d", L.length);
	
	return 0;
}

输出

0 0 0 0 0 0 0 0 0 0 length=0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

动态分配方式

#include 
#include 
#define InitSize 10 //默认最大长度

typedef struct{
	int *data;	//指示动态分配数组的指针 
	int MaxSize; //最大容量 
	int length; //顺序表的当前长度 
}SeqList; 

/**
* 初始化 
*
* @param L 顺序表指针 
*/
void InitList(SeqList &L){
	//用 malloc 函数申请一片连续的存储空间 
	L.data=(int *)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
	
	for(int i=0; i<InitSize; i++)
		L.data[i]=0; //初始化为0 
}

/**
* 动态增加数组长度 
*
* @param L 顺序表指针 
* @param len 增加的长度
*/
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; //扩大长度 
	free(p); //释放原来的内存空间 
} 

int main(){
	SeqList L;
	InitList(L);
	
	for(int i=0; i<L.MaxSize; i++)
		printf("%d ", L.data[i]);
	printf("\n原来size=%d", L.MaxSize);
	
	IncreaseSize(L, 5);
	printf("\n当前size=%d\n", L.MaxSize);
	
	return 0;
}

输出

0 0 0 0 0 0 0 0 0 0
原来size=10
当前size=15

--------------------------------
Process exited with return value 0
Press any key to continue . . .

插入

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

操作小记

代码

#include 
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	return 0;
}

效果：

2 3 0 0 0 0 0 0 0 0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

删除

/**
* 删除
*
* @param L 顺序表指针
* @param i 输出的位置，即位序i 
* @param e 删除的值 
* @return 是否插入成功 
*/
bool ListDelete(SqList &L, int i, int &e){
	if(i<1 || i>L.length)
		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--;  //线性表长度减1 
	
	return true;
}

操作小记

代码

#include 
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 删除
*
* @param L 顺序表指针
* @param i 输出的位置，即位序i 
* @param e 删除的值 
* @return 是否插入成功 
*/
bool ListDelete(SqList &L, int i, int &e){
	if(i<1 || i>L.length)
		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--;  //线性表长度减1 
	
	return true;
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	int e=-1;
	ListDelete(L, 1, e);
	printf("\nres=%d\n", e);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	return 0;
}

效果

2 3 0 0 0 0 0 0 0 0
res=2
3 3 0 0 0 0 0 0 0 0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

查找

按位查找

/**
* 按位查找
*
* @param L 顺序表指针
* @param i 位序i  
* @return 该位置的值
*/
int GetElem(SqList L, int i){
	return L.data[i-1];
}

操作小记

代码

#include 
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 按位查找
*
* @param L 顺序表指针
* @param i 位序i 
* @return 该位置的值
*/
int GetElem(SqList L, int i){
	return L.data[i-1];
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);

	printf("\n第一个值为：%d", GetElem(L, 1)); 
	
	return 0;
}

效果

2 3 0 0 0 0 0 0 0 0
第一个值为：2
--------------------------------
Process exited with return value 0
Press any key to continue . . .

按值查找

/**
* 按值查找
*
* @param L 顺序表指针
* @param e 获取的值 
* @return 该值的位序 
*/
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; //退出循环，说明查找失败 
}

操作小记

代码

#include 
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 按值查找
*
* @param L 顺序表指针
* @param e 获取的值 
* @return 该值的位序 
*/
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; //退出循环，说明查找失败 
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);

	printf("\n元素值为3的位序：%d", LocateElem(L, 3)); 
	
	return 0;
}

效果

2 3 0 0 0 0 0 0 0 0
元素值为3的位序：2
--------------------------------
Process exited with return value 0
Press any key to continue . . .