顺序表的定义及其实现

顺序表

用顺序存储的方式实现线性表，可以采用两种实现方式，静态分配与动态分配。

特点

1. 随机访问
2. 存储密度高
3. 拓展容量不方便
4. 插入、删除数据元素不方便

顺序存储

把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的领接关系来实现

线性表

是具有相同数据类型的n(n>=0)个数据元素的有限序列。

静态顺序表的实现

#include<stdio.h>
#define MaxSize 10      //定义最大长度

typedef struct{
	int data[MaxSize];  //使用数组存放数据元素
	int length;         //当前长度
}SeqList;

//基本操作--初始化
void InitList(SeqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;    //将所有元素设为默认初始值（可省略）
	L.length = 0;       //顺序表初始长度为0
}

//基本操作--销毁和初始化相同

//基本操作--插入
bool ListInsert(SeqList &L,int i,int e){  //在顺序表L的位序i处插入元素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;
}

//基本操作--删除
bool ListDelete(SeqList &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--;   //长度减1
	return true;
}

//基本操作--按位查找
bool GetElem(SeqList L,int i,int &e){
	if(i<1||i>L.length)
		return false;
	e=L.data[i-1];
		return true;
}

//基本操作--按值查找
int LocateElem(SeqList L,int e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0;
}


int main(){
	SeqList L;          //声明一个顺序表
	InitList(L);        //初始化顺序表

	//插入操作
	if(ListInsert(L,1,0))
		printf("插入成功!\n");
	else
		printf("插入失败!\n");
	
	//删除操作
	int e = -1;
	if(ListDelete(L,3,e))
		printf("已删除，删除元素值为%d\n",e);
	else
		printf("位序i不合法，删除失败\n");

	//按位查找操作
	if(GetElem(L,1,e))
		printf("该位置值为%d\n",e);
	else 
		printf("位序i不合法，查找失败\n");
	
	//按值查找操作
	if(LocateElem(L,0))
		printf("存在，位序为%d\n",LocateElem(L,0));
	else
		printf("不存在\n");

	for(int i=0;i<L.length;i++)
		printf("data[%d]=%d\n",i,L.data[i]);
	return 0;
}

动态顺序表的实现

#include<stdlib.h>  //malloc、free函数的头文件


#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;
	L.MaxSize = InitSize;
}
int LocateElem(SeqList L,int e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0;
}
//增加动态数组长度
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;
}