C++实现顺序表操作（实验2—作业）

关注

原创 2024-09-10 20:20:11 640 阅读 AI 写同款· GEO 优化 ›

C++实现顺序表的基本操作 C++实现顺序表的基本操作为了对数据结构线性表中的顺序表进行练习，我写了一段可以实现顺序表创建、插入、删除、排序、打印等基本操作的代码。 #include<iostream> #include<algorithm> using namespace std; #define MAXSIZE 1000 #define OVERFLOW -2 #define ERROR 1 ... 阅读详情

在C++中，顺序表是一个线性表的一种实现方式。它是一种可以按照元素在内存中的物理顺序依次存储的数据结构。顺序表在内存中是连续的，可以通过下标来直接访问元素。

C++中的顺序表可以使用数组来实现。数组是一种固定大小的连续内存块，可以通过索引访问元素。在C++中，可以使用普通数组或者动态数组来实现顺序表。

普通数组是在编译时指定大小的数组，大小在运行时不能改变。可以使用下标来访问数组中的元素，通过将元素插入或删除来实现顺序表的操作。使用普通数组实现的顺序表的优点是访问速度快，缺点是大小固定，不能动态调整。

动态数组是使用关键字new在堆上分配内存的数组，大小可以在运行时动态调整。可以使用指针来访问动态数组中的元素，通过重新分配内存来实现顺序表的操作。使用动态数组实现的顺序表的优点是可以动态调整大小，缺点是访问速度相对较慢。

除了数组，还可以使用链表来实现顺序表。链表是一种非连续的数据结构，在C++中可以使用指针实现。链表中的每个节点都包含一个元素和指向下一个节点的指针。通过遍历链表来访问元素，通过插入或删除节点来实现顺序表的操作。链表实现的顺序表的优点是可以动态调整大小，缺点是访问速度相对较慢。

如下是一段用数组实现顺序表的过程

这段 C++代码实现了顺序表的初始化、插入、打印、置空、销毁、查找、删除、排序以及求并集、交集和差集等操作，并通过在主函数中对两个顺序表进行一系列操作来展示这些功能，最后还实现了在并集中查找特定元素的功能，并在结束时销毁了所有顺序表。

#include<bits/stdc++.h>//万能头文件
using namespace std;//命名空间

#define MAXSIZE 100 //最大长度
#define OVERFLOw -2
#define OK 1
#define ERROR 0

typedef int Status;
typedef char eleType;//数据类型

typedef struct{
	eleType *elements;
	int length;
}SqList;//定义顺序表

//顺序表的初始化
Status SqListInit(SqList &L){
	L.elements = new eleType[MAXSIZE];
	if(!L.elements) exit(OVERFLOw);
	L.length = 0;//长度为0
	return OK;//创建完毕
}
//顺序表的插入数据
Status SqListInsert(SqList &L,int i,eleType e){
	int j;
	if(i<1||i>L.length+1) return ERROR;//插入不合法
	if(i==MAXSIZE) return ERROR;//顺序表满了
	for ( j=L.length-1 ; j>=i-1; j--) {
		//逐个元素右移
		L.elements[j+1] = L.elements[j] ;
	}
	L.elements[i-1] = e ;   //插入e 
	L.length++;//L的长度加1
	return OK; //插入成功
}
//顺序表的打印
void SqListPrint(SqList &L){
	for(int i = 0;i<L.length;i++){
		cout<<L.elements[i]<<"\t";
	}
	cout<<endl;
}
//顺序表的置空
Status SqListEmpty(SqList &L){
	L.length = 0;
	L.elements = NULL;
	return OK;
}
//顺序表的销毁
void SqListDestroy(SqList &L){
	//判断是否为空
	if(L.elements){
		delete[]L.elements;//销毁空间
		L.length = 0;//长度为0
		L.elements=NULL;//置空
	}
}
//顺序表的查找
Status SqListFind(SqList &L,eleType e){
	for(int i  =0 ;i<L.length;i++){
		if(L.elements[i]==e){
			return i+1;//第几个出现，消除索引偏移
		}
	}
	return 0;
}
//顺序表元素删除
Status SqListDelete(SqList &L,int i){
	int j;
	if ((i <1) || (i > L.length)) return ERROR;   // 删除位置不合法
	for (j=i;j<=L.length-1; j++)
		L.elements[j-1]=L.elements[j]; // 被删除元素之后的元素前移
	L.length--;   //表长减 1
	return OK;
}

//顺序表排序
Status SqListSort(SqList &L){
	sort(L.elements,L.elements+L.length);
	return OK;
}

//顺序表并集（有序）
SqList SqListMerge(SqList &L1,SqList &L2){
	int i=0,j=0,t=1;
	SqList L3;//用来接收L1 L2的合集
	SqListInit(L3);//⭐初始化L3用来接收
	int preValue = -1;//防止最后存入剩余元素那一步元素重复
	while(i<L1.length&&j<L2.length){
		if(L1.elements[i]==L2.elements[j]){
			if(preValue!=L1.elements[i]){
				preValue=L1.elements[i];
				SqListInsert(L3,t++,L1.elements[i]);
				
			}i++;j++;//存入相对较小元素后对应坐标加1 
		}else if(L1.elements[i]<L2.elements[j]){
			if(preValue!=L1.elements[i]){
				preValue=L1.elements[i];
				SqListInsert(L3,t++,L1.elements[i]);
			}	i++;
		}else {
			if(preValue!=L2.elements[j]){
				preValue=L2.elements[j];
				SqListInsert(L3,t++,L2.elements[j]);
				
			}j++;
		}
	}
	//L1还有剩余
	while(i<L1.length){
		if(preValue!=L1.elements[i]){
			preValue=L1.elements[i];
			SqListInsert(L3,t++,L1.elements[i]);
			
		}i++;
	}
	//L2还有剩余
	while(j<L2.length){
		if(preValue!=L2.elements[j]){
			preValue=L2.elements[j];
			SqListInsert(L3,t++,L2.elements[j]);
		}
		j++;	
	}
	return L3;
}
//顺序表的交集（有序）
SqList SqListInserSection(SqList &L1,SqList &L2){
	SqList L4;
	SqListInit(L4);
	int i = 0,j = 0, t = 1;
	int preValue = -1;//防止最后存入剩余元素那一步元素重复
	while(i<L1.length&&j<L2.length){
		if(L1.elements[i]==L2.elements[j]){
			if(preValue!=L1.elements[i]){
				preValue=L1.elements[i];
				SqListInsert(L4,t++,L1.elements[i]);
			}i++;j++;//存入相对较小元素后对应坐标加1 
		}else if(L1.elements[i]<L2.elements[j]){
			i++;
		}else {
			j++;
		}
	}
	return L4;
}
//顺序表的差
SqList SqListDiff(SqList &L1,SqList &L2){
	SqList L5;
	SqListInit(L5);
	int i = 0,j = 0, t = 1;
	while(i<L1.length&&j<L2.length){
		if(L1.elements[i]==L2.elements[j]){
			i++;j++;
		}else if(L1.elements[i]<L2.elements[j]){
			SqListInsert(L5,t++,L1.elements[i++]);
		}else {
			j++;
		}
	}
	while(i<L1.length){
		SqListInsert(L5,t++,L1.elements[i++]);
	}
	return L5;
}
int main(){
	//L
	SqList L1;
	SqListInit(L1);
	for(int i =1;i<=10;i++){
		int x = 0-i+10+97;
		SqListInsert(L1,i,x);
	}
	cout<<"L1:  "<<endl;
	SqListPrint(L1);
	//L2
	SqList L2;
	SqListInit(L2);
	for(int i =1;i<=10;i++){
		int x = 0-i+15+97;
		SqListInsert(L2,i,x);
	}
	cout<<"L2:  "<<endl;
	SqListPrint(L2);
	
	cout<<"L1排序后:"<<endl;
	SqListSort(L1);
	SqListPrint(L1);
	
	cout<<"L2排序后:"<<endl;
	SqListSort(L2);
	SqListPrint(L2);
	
	
	cout<<"L2排序后与L1排序后合集 L3"<<endl;
	SqList L3 = SqListMerge(L1,L2);
	SqListPrint(L3);
	
	cout<<"L2排序后与L1排序后交集 L4"<<endl;
	SqList L4 = SqListInserSection(L1,L2);
	SqListPrint(L4);
	
	cout<<"L1 - L2 = L5"<<endl;
	SqList L5 = SqListDiff(L1,L2);
	SqListPrint(L5);
	
	cout<<"L2 - L1 = L6"<<endl;
	SqList L6 = SqListDiff(L2,L1);
	SqListPrint(L6);
	
	int goal;
	cout<<"请输入要在合集L3中查找的数字:"<<endl;
	cin>>goal;
	if(SqListFind(L3,goal)!=0){
		cout<<goal<<"在第"<<SqListFind(L3,goal)<<"个出现"<<endl;
	}else{
		cout<<goal<<"未在L3中出现"<<endl;
	}

	
	SqListDestroy(L1);
	SqListDestroy(L2);
	SqListDestroy(L3);
	SqListDestroy(L4);
	SqListDestroy(L5);
	SqListDestroy(L6);
	return 0;
}

收录于