数据结构_顺序表实现及其操作

数据结构_顺序表实现及其操作

程序大量参考自王道《数据结构》以及博主lady_killer9的数据结构专栏

---

主要实现顺序表的建立，顺序表的基本操作以及部分王道课后习题：

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

• InitList(SqList &L): 初始化表，构造一个空的线性表;
• Length(SqList L): 求表长。返回线性表L的长度;
• LocateElem(SqList L,ElemType e): 按值查找，查找表中是否有值e;
• GetElem(SqList L,int i): 按位查找，获取第i个位置的元素值;
• ListInsert(SqList &L,int i,ElemType e): 在第i个位置插入元素e，改变了原表的值，所以用引用’&'符号;
• ListDelete(SqList &L,int i,ElemType &e):删除第i个位置的元素，并用e返回被删除的值;
• PrintList(SqList L): 输出表中所有元素;
• Empty(SqList L): 判空;
• DestroyList(SqList &L): 销毁线性表，释放空间;
  代码实现：

/*
Author：Xi_Ting Fro
Project：Sequence-List
Date：2021/8/8
实现顺序表的基本操作
InitList(SqList &L):					初始化表，构造一个空的线性表;
Length(SqList L):						求表长。返回线性表L的长度;
LocateElem(SqList L,ElemType e):		按值查找，查找表中是否有值e;
GetElem(SqList L,int i):				按位查找，获取第i个位置的元素值;
ListInsert(SqList &L,int i,ElemType e):	在第i个位置插入元素e，改变了原表的值，所以用引用'&'符号;
ListDelete(SqList &L,int i,ElemType &e):删除第i个位置的元素，并用e返回被删除的值;
PrintList(SqList L):					输出表中所有元素;
Empty(SqList L):						判空;
DestroyList(SqList &L):					销毁线性表，释放空间;
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define InitSize 100
#define ElemType int
#define Status int
using namespace std;

/*******************************************////************************************************************/
/*******************************************////*顺序表基本操作*************************************************************/
/*******************************************////************************************************************/

/*
*
*
//空间动态分配
typedef struct{
	ElemType *data;						//动态分配的数组的指针
	int length;							//顺序表当前长度
	int MaxSize;						//表的最大容量 
}SqList;								//动态分配语句：L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

void InitList(SqList &L){				//初始化线性表 
	L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);  //声明时不开空间，初始化时才分配空间 
	L.length=0; 
	L.MaxSize=InitSize;
} 
void IncreaseSize(SqList &L,int len){	//增加线性表长度 
	int *p = L.data;					//保存原表数据
	L.data=(ElemType*)malloc(sizeof(ElemType)*(L.MaxSize+len)); //重新开辟更大空间
	for(int i=0 ;i<length ;i++){		//重新赋值回data 
		L.data[i] = p[i];
	}
	L.MaxSize +=len;
	free(p); 
}
//空间动态分配
*
*
**/

//空间静态分配
typedef struct{
	ElemType data[MaxSize];				//表中元素
	int length;							//表长
}SqList;
//初始化表L，建空表
void InitList(SqList &L){
	for (int i=0;i<MaxSize;i++){
		L.data[i] = 0;					//清理脏数据 
		} 
	L.length = 0;					//初始化表的时候表中实际存储的数据为0 
} 



//初始化前n个数据 
bool CreateList(SqList &L,int n){		//向表中写入n个数据 
	if(n<0||n>MaxSize)
	return false;
	printf("初始化表中数据，请输入%d个数：\n",n); 
	for (int i=0 ;i<n; i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
	return true;
}
//清空顺序表
void ClearList(SqList &L) {
	L.length = 0;
}
//在表中第i个位置插入元素e
bool InsertList(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1)					//不存在第0个位置，第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];				//长度是比下标大1的
	
	L.data[i-1]=e;						//位置比数组下标大1
	L.length++;							//插入元素e，长度加1
	return true; 
} 
//删除第i个位置元素，用e返回被删除值 
bool ListDelete(SqList &L,int i,ElemType &e){
	if(i<1||i>L.length)
	return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++)			//第i个元素之后的所有元素前移一位
	L.data[j-1]=L.data[j];				//j<length即可，因为位置比下标大1 
	
	L.length--;							//时刻记得修改元素数量L.length要变化 
	return true;
}
//按值查找，返回位置序号 
int LocateElem(SqList L,ElemType e){
	int i;
	for(i=0;i<L.length;i++){
		if(L.data[i]==e)
		return i+1; 
	}
	
	return 0;							//循环结束,查找失败 
	
} 
//显示顺序表的所有元素
void PrintList(SqList L){
	printf("当前顺序表所有元素：");
	for(int i=0;i<L.length;i++)
	printf("%d ",L.data[i]);
	printf("\n");
} 
/*******************************************////************************************************************/
/*******************************************////*功能函数*//************************************************************/
/*******************************************////************************************************************/

//在表中插元素功能的函数，调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果 
void Insert(SqList &L){
	int place;
	ElemType e;
	bool flag; 
	printf("请输入要插入的位置及元素值e:\n");
	scanf("%d%d",&place,&e);			//若更改ElemType，则要更改相应的scanf占位符 
	flag=InsertList(L,place,e);
	if(flag){
		printf("在第|%d|个位置插入元素后，表中元素为：\n",place);
		PrintList(L);
	}
}
//删除表中元素功能的函数，调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果 
void Delete(SqList &L){
	int place;
	ElemType e;
	bool flag;
	printf("请输入要删除的元素位置:\n");
	scanf("%d",&place);
	flag=ListDelete(L,place,e);
	if(flag){
		printf("删除第|%d|个元素|%d|后，表中元素为：\n",place,e);//若更改ElemType，则要更改相应的占位符 	
		PrintList(L);
	}
} 
//查找功能函数，调用LocatElem函数定位
void Search(SqList L){
	ElemType e;
	int place;
	printf("请输入要查找的元素：");
	scanf("%d",&e);
	place=LocateElem(L,e);
	if(place){
		printf("该元素位置为：|%d|\n",place);
	}
	else{
		printf("未找到该元素！\n");
	}
}

/*******************************************////************************************************************/
/*******************************************////*王道例题*//************************************************************/
/*******************************************////************************************************************/

/*1.从顺序表中删除表中最小值元素，并返回被删元素，空出位置由最后一个元素补，若顺序表为空，则显示出错信息并退出*/
bool Operate_Del_Min(SqList &L,ElemType &e){//操作函数 
	int place;								//记录被删位置 
	e=L.data[0];							//时刻用e保存最小值 
	if(L.length==0){						//判空 
		printf("表空！！\n");
		return false;
	}	
	
	for(int i=0;i<L.length;i++){
		if(e>L.data[i]){
			e=L.data[i];
			place=i; 
		}	
	}
	L.data[place]=L.data[L.length-1];		//最后一个元素赋值到被删元素位置 
	L.length--;								//L.length-1，之前的最后一个元素自然被覆盖
	return true; 
} 
void Function_Del_Min(SqList &L){			//功能函数 
	ElemType e;
	bool flag;
	flag=Operate_Del_Min(L,e);
	if(flag){
		printf("删除最小元素|%d|后，数据为：\n",e);
		PrintList(L);
	}
	else{
		printf("Error!\n");
	}
}


/*2.逆置顺序表L的元素 */
void Reverse(SqList &L){
	ElemType temp;
	printf("调用逆置顺序表函数\n");
	for(int i=0;i<L.length/2;i++){
		temp=L.data[i];
		L.data[i]=L.data[L.length-1-i];
		L.data[L.length-1-i]=temp;
	}
	PrintList(L);
} 



/*3.删除值为X的元素*/
/*思路：用k记录不等于X的个数，k与i增加，若全不等于X，
则k与i一直保持同步，若有一个=X，则k滞后i一位，以此类推，
当出现等于x时，k就不加，那位置值就会被后面的占据，
相当于边找边移动，最后更改长度，应为k*/
void Del_X(SqList &L,ElemType X){
	int k=0;							//k记录不等于X的个数 
	for(int i=0;i<L.length;i++){
		if(L.data[i]!=X){
			L.data[k]=L.data[i];
			k++;						//若有值为X的元素出现，则k将出现滞后i的情况，后值依次赋到前面去 
		}
	} 
	L.length=k; 
	

} 
void Del_X2(SqList &L,ElemType X){
	int k=0,i=0;						//k记录等于X的个数 
	while(i<L.length){
		if(L.data[i]==X) 
		k++;
		else
		L.data[i-k]=L.data[i];
		
		i++;							//i一直++，k只有遇到等于X才++ 
		}
	L.length=L.length-k; 
}


/*4.从有序表中删除s-t之间的所有元素*/
/*思路：找到s和t的位置，用i，j将后面的值占位到ij之间*/
bool Del_s_t(SqList &L,ElemType s,ElemType t){ 
	int i,j;
	if(s>=t){
	return false; 
	} 
	for(i=0;L.data[i]<s&&i<L.length;i++)	//找到第一个大于等于s的数L.data[i]
	;
	if(i>=L.length)							//没有大于S的数
	return false;
	for(j=i;L.data[j]<=t&&j<L.length;j++) 	//找到第一个大于t的数data[j]
	;
	for(;j<L.length;j++,i++) 				//j大于i 
	L.data[i]=L.data[j];
	
	L.length=i;
	return true;	 
} 




int main(void){
	SqList L;							//声明表，空间分配
	int n=10;							 
	InitList(L);						//初始空表 将length置为0 
	CreateList(L,n);
//	Insert(L);
//	Delete(L);
//	Search(L);
//	Function_Del_Min(L);
	Reverse(L);
	return 0; 
	 
}

---

总结：

基本实现了顺序表的框架搭建，完成了顺序表的基本操作及部分例题。

---

删除顺序表中所有值为X的元素：

思路：用k记录不等于X的个数，k与i增加，若全不等于X，
则k与i一直保持同步，若有一个=X，则k滞后i一位，以此类推，
当出现等于x时，k就不加，那位置值就会被后面的占据，
相当于边找边移动，最后更改长度，应为k

/*3.删除值为X的元素*/
/*思路：用k记录不等于X的个数，k与i增加，若全不等于X，
则k与i一直保持同步，若有一个=X，则k滞后i一位，以此类推，
当出现等于x时，k就不加，那位置值就会被后面的占据，
相当于边找边移动，最后更改长度，应为k*/
void Del_X(SqList &L,ElemType X){
	int k=0;							//k记录不等于X的个数 
	for(int i=0;i<L.length;i++){
		if(L.data[i]!=X){
			L.data[k]=L.data[i];
			k++;						//若有值为X的元素出现，则k将出现滞后i的情况，后值依次赋到前面去 
		}
	} 
	L.length=k; 
	

} 
void Del_X2(SqList &L,ElemType X){
	int k=0,i=0;						//k记录等于X的个数 
	while(i<L.length){
		if(L.data[i]==X) 
		k++;
		else
		L.data[i-k]=L.data[i];
		
		i++;							//i一直++，k只有遇到等于X才++ 
		}
	L.length=L.length-k; 
}

其他操作及功能可自行查看源程序及注释，然后在主函数中调用