利用线性表的顺序结构求集合的并、交、差、补（C语言实现）

2024-09-01 07:58
文章标签 语言 实现 结构 顺序 集合 线性表

本文主要是介绍利用线性表的顺序结构求集合的并、交、差、补（C语言实现），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

昨天用数据结构中的线性表的顺序结构实现了关于集合的并、交、差、补的集合运算，做个记录，希望也能帮助到其他人。

一、算法分析


　　（1）用数组A，B，C，E表示集合。假定A={1,3，4，5，6，7，9，10},
　　B={2，,3，4，7，8，10}, E={1,2，3，4，5，6，7，8，9，10},
　　输入数组A，B，E（全集），输入数据时要求检查数据是否重复（集合中的数据要求不重复），要求集合A，B是集合E的子集。
　　
　　（2）两个集合的并运算：把数组A中各个元素先保存在数组C中。将数组B中的元素逐一与数组A中的元素进行比较，把不相同的元素添加到数组C中，数组C便是集合A和集合B的并。
　　 C语言算法（线性表顺序结构实现）：

/**求集合的并集的函数**/
void Union_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length=0;
for(i = 0; i < La.length; i++)
Lc.elem[Lc.length++]=La.elem[i];
for(i = 1; i <= Lb.length; i++){
elem = Lb.elem[i-1];
if(!LocateElem_Sq(La,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}


（3）两个集合的交运算：把数组A中元素逐一与数组B中的元素进行比较，将相同的元素放在数组C中，数组C便是集合A和集合B的交。
　　C语言算法（线性表顺序结构实现）：

/**求集合的交集的函数**/
void Mix_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length = 0;
for(i = 1; i <= La.length; i++){
elem = La.elem[i-1];
if(LocateElem_Sq(Lb,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}


（4）两个集合的差运算：将数组A中的元素逐一与数组B中的元素进行比较，把数组A与数组B不同的元素保存在数组C中，数组C便是集合A和集合B的差A-B。
　　C语言算法（线性表顺序结构实现）：

/**求集合的差集函数**/
void Differ_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length = 0;
for(i = 1; i <= La.length; i++){
elem = La.elem[i-1];
if(!LocateElem_Sq(Lb,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}


（5）集合的补运算：将数组E中的元素逐一与数组A中的元素进行比较，把不相同的元素保存到数组C中，数组C便是集合A关于集合E的补集。
　　求补集是一种特殊的集合差运算。
　　 C语言算法（线性表顺序结构实现）：

/**求集合的补集函数**/
void Comple_Sq(SqList La,SqList Lb,SqList &Lc,SqList &Ld){
int i;
ElemType elem;
Ld.length = 0;
Union_Sq(La,Lb,Lc);
for(i = 1; i <= Lc.length; i++){
elem = Lc.elem[i-1];
if(!LocateElem_Sq(La,elem,Equal))
ListInsert_Sq(Ld,Ld.length+1,elem);
}
}


二、执行效果图如下：






三、源程序如下：

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define LIST_INIT_SIZE 100 //初始表空间大小
#define LISTINCREMENT 10 //表长增量
typedef int Status; /**Status是函数类型，其值是函数结果状态代码，如OK等**/
typedef char ElemType; /*ElemType类型根据实际情况而定，这里假设为char*/
/**顺序表的定义**/
typedef struct{
ElemType *elem; /**储存空间基地址**/
int length; /**当前长度**/
int listsize; /**当前分配的储存容量（以sizeof(Elemtype)为单位）**/
}SqList;SqList La,Lb,Lc,Ld; /**定义全局变量**//**构造一个空的线性表L**/
Status InitList_Sq(SqList &L){
L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
if(!L.elem) exit(OVERFLOW); /**储存分配失败**/
L.length = 0; /**空表长度为0**/
L.listsize = LIST_INIT_SIZE; /**初始储存容量**/
return OK;
} /**该函数的时间复杂度为O(n)**//**在顺序表的逻辑为i的位置插入新元素e的函数**/
Status ListInsert_Sq(SqList &L,int i,ElemType e){
ElemType *newbase,*p,*q;
//i的合法值为(1 <= i <= L.length_Sq(L) + 1)
//异常处理
if(i < 1 || i > L.length + 1) return ERROR;
if(L.length >= L.listsize){ //当前储存空间已满，增加分配
newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT) * sizeof(ElemType));
if(!newbase) exit(OVERFLOW); //储存分配失败
L.elem = newbase; //新基址
L.listsize += LISTINCREMENT; //增加储存容量
}
q = &(L.elem[i - 1]); //q为插入位置
for(p = &(L.elem[L.length - 1]); p >= q; --p) 
*(p + 1) = *p; //插入位置及之后的元素往右移
*q = e; //插入e
++L.length; //表长加1
return OK;
}/**创建一个线性表，即输入数据,根据集合定义：集合中的元素不能相等创建**/
void CreateList_Sq(SqList &L){
ElemType ch;
int inlist = FALSE,j;
while((ch) != '\n'){
scanf("%c",&ch);
for(j = 0; j < L.length; j++)
if(ch == L.elem[j]){
inlist = TRUE;
break;
}
else
inlist = FALSE;
if(!inlist && ch != '\n') ListInsert_Sq(L,L.length+1,ch);
}
}
/**判断两元素是否相等,若相等则返回TRUE;否则返回FALSE**/
Status Equal(ElemType a,ElemType b){
if(a == b) return TRUE;
else return FALSE;
}/**在顺序线性表L中查找第1个与e满足compare()的元素位序，若找到，则返回其在L中的位序，否则返回0**/
int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){
ElemType *p;
int i;
i = 1; //i的初值为第1个元素的位序
p = L.elem; //p的初值为第1个元素的储存位置
while(i <= L.length && !(* compare)(*p++,e)) ++i;
if(i <= L.length) return i;
else return 0;
} //该函数的时间复杂度为O(n)/*销毁线性表的函数*/
Status Clear_Sq(SqList &L){
ElemType elem;
free(L.elem);
L.elem = NULL;
return OK;
}/**打印顺序表函数**/
void Print_Sq(SqList L){
int i;
for(i = 0; i < L.length; i++)
printf("%2c",L.elem[i]);
if(L.length == 0) printf("该集合为空集"); 
printf("\n\t\t\t#\t此集合中的个数 n = %d\n\n",L.length);
}/**求集合的并集的函数**/
void Union_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length=0;
for(i = 0; i < La.length; i++)
Lc.elem[Lc.length++]=La.elem[i];
for(i = 1; i <= Lb.length; i++){
elem = Lb.elem[i-1];
if(!LocateElem_Sq(La,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}/**求集合的交集的函数**/
void Mix_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length = 0;
for(i = 1; i <= La.length; i++){
elem = La.elem[i-1];
if(LocateElem_Sq(Lb,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}/**求集合的差集函数**/
void Differ_Sq(SqList La,SqList Lb,SqList &Lc){
int i;
ElemType elem;
Lc.length = 0;
for(i = 1; i <= La.length; i++){
elem = La.elem[i-1];
if(!LocateElem_Sq(Lb,elem,Equal))
ListInsert_Sq(Lc,Lc.length+1,elem);}
}/**求集合的补集函数**/
void Comple_Sq(SqList La,SqList Lb,SqList &Lc,SqList &Ld){
int i;
ElemType elem;
Ld.length = 0;
Union_Sq(La,Lb,Lc);
for(i = 1; i <= Lc.length; i++){
elem = Lc.elem[i-1];
if(!LocateElem_Sq(La,elem,Equal))
ListInsert_Sq(Ld,Ld.length+1,elem);
}
}void Index_Sq(){
char s;
int l;
l = 1;InitList_Sq(La);
printf("\t\t\t|****** 请输入你的第一个集合：******|\n");
printf("\t\t\t");
CreateList_Sq(La);
printf("\t\t\t#\t集合A为");
Print_Sq(La); //实现表LA的操作
printf("\t\n\n");InitList_Sq(Lb);
printf("\t\t\t|****** 请输入你的第二个集合：******|\n");
printf("\t\t\t");
CreateList_Sq(Lb);
printf("\t\t\t#\t集合B为");
Print_Sq(Lb); //实现表LB的操作
printf("\t\n\n");InitList_Sq(Lc); //初始化表LC的操作
InitList_Sq(Ld); //初始化表Ld的操作
while(l){
printf("\t\t|******* 您可以选择a、b、c或者d执行以下操作 ******|\n\n");
printf("\t\t|************* a、进行集合的并运算 ***************|\n");
printf("\t\t|************* b、进行集合的交运算 ***************|\n");
printf("\t\t|************* c、进行集合的差运算 ***************|\n");
printf("\t\t|************* d、进行集合的补运算 ***************|\n");
printf("\t\t|************* e、重新建立两个集合 ***************|\n");
printf("\t\t\t");
scanf("%c",&s);
switch(s){
case 'a' :  Union_Sq(La,Lb,Lc);
printf("\t\t\t#\t集合A与集合B的并集为:");
Print_Sq(Lc); //实现表LA与表LB并集的操作
printf("\n");
break;
case 'b' : Mix_Sq(La,Lb,Lc);
printf("\t\t\t#\t集合A与集合B的交集为:");
Print_Sq(Lc); //实现表LA与表LB交集的操作
printf("\n");
break;
case 'c' : Differ_Sq(La,Lb,Lc);
printf("\t\t\t#\t集合A与集合B的差集为:");
Print_Sq(Lc); //实现表LA与表LB差集的操作
printf("\n");
break;
case 'd' : Comple_Sq(La,Lb,Lc,Ld);
printf("\t\t\t#\t集合A的补集为:");
Print_Sq(Ld); //实现表LA的补集操作
printf("\n");
break;
case 'e' : Clear_Sq(La);
Clear_Sq(Lb);
Clear_Sq(Lc);
Clear_Sq(Ld);getchar();
Index_Sq();break;
default  : printf("\t\t\t#\tenter data error!\n");
printf("\n");
}
printf("\t\t|**** 您是否还想继续计算。是请输入1，否请输入0 ****|\n");
printf("\t\t\t");
scanf("%d",&l);
getchar();
}//while语句判断是否继续
printf("\n\t\t|**************** 欢迎使用，谢谢！*****************|\n");
getchar();
}
int main(){
printf("\t\t|************* 欢迎使用集合操作运算器 ************|\n");
Index_Sq();return 0;
}

这篇关于利用线性表的顺序结构求集合的并、交、差、补（C语言实现）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1126376。

相关文章

SpringBoot集成redisson实现延时队列教程

SpringBoot集成redisson实现延时队列教程

《SpringBoot集成redisson实现延时队列教程》文章介绍了使用Redisson实现延迟队列的完整步骤,包括依赖导入、Redis配置、工具类封装、业务枚举定义、执行器实现、Bean创建、消费... 目录1、先给项目导入Redisson依赖2、配置redis3、创建 RedissonConfig 配
阅读更多...
SpringBoot分段处理List集合多线程批量插入数据方式

SpringBoot分段处理List集合多线程批量插入数据方式

《SpringBoot分段处理List集合多线程批量插入数据方式》文章介绍如何处理大数据量List批量插入数据库的优化方案：通过拆分List并分配独立线程处理,结合Spring线程池与异步方法提升效率... 目录项目场景解决方案1.实体类2.Mapper3.spring容器注入线程池bejsan对象4.创建
阅读更多...
Python的Darts库实现时间序列预测

Python的Darts库实现时间序列预测

《Python的Darts库实现时间序列预测》Darts一个集统计、机器学习与深度学习模型于一体的Python时间序列预测库,本文主要介绍了Python的Darts库实现时间序列预测,感兴趣的可以了解... 目录目录一、什么是 Darts？二、安装与基本配置安装 Darts导入基础模块三、时间序列数据结构与
阅读更多...
Python使用FastAPI实现大文件分片上传与断点续传功能

Python使用FastAPI实现大文件分片上传与断点续传功能

《Python使用FastAPI实现大文件分片上传与断点续传功能》大文件直传常遇到超时、网络抖动失败、失败后只能重传的问题,分片上传+断点续传可以把大文件拆成若干小块逐个上传,并在中断后从已完成分片继... 目录一、接口设计二、服务端实现（FastAPI）2.1 运行环境2.2 目录结构建议2.3 serv
阅读更多...
C#实现千万数据秒级导入的代码

C#实现千万数据秒级导入的代码

《C#实现千万数据秒级导入的代码》在实际开发中excel导入很常见,现代社会中很容易遇到大数据处理业务,所以本文我就给大家分享一下千万数据秒级导入怎么实现,文中有详细的代码示例供大家参考,需要的朋友可... 目录前言一、数据存储二、处理逻辑优化前代码处理逻辑优化后的代码总结前言在实际开发中excel导入很
阅读更多...
SpringBoot+RustFS 实现文件切片极速上传的实例代码

SpringBoot+RustFS 实现文件切片极速上传的实例代码

《SpringBoot+RustFS实现文件切片极速上传的实例代码》本文介绍利用SpringBoot和RustFS构建高性能文件切片上传系统,实现大文件秒传、断点续传和分片上传等功能,具有一定的参考... 目录一、为什么选择 RustFS + SpringBoot？二、环境准备与部署2.1 安装 RustF
阅读更多...
Nginx部署HTTP/3的实现步骤

Nginx部署HTTP/3的实现步骤

《Nginx部署HTTP/3的实现步骤》本文介绍了在Nginx中部署HTTP/3的详细步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学... 目录前提条件第一步：安装必要的依赖库第二步：获取并构建 BoringSSL第三步：获取 Nginx
阅读更多...
MyBatis Plus实现时间字段自动填充的完整方案

MyBatis Plus实现时间字段自动填充的完整方案

《MyBatisPlus实现时间字段自动填充的完整方案》在日常开发中,我们经常需要记录数据的创建时间和更新时间,传统的做法是在每次插入或更新操作时手动设置这些时间字段,这种方式不仅繁琐,还容易遗漏,... 目录前言解决目标技术栈实现步骤1. 实体类注解配置2. 创建元数据处理器3. 服务层代码优化填充机制详
阅读更多...
Python实现Excel批量样式修改器(附完整代码)

Python实现Excel批量样式修改器(附完整代码)

《Python实现Excel批量样式修改器(附完整代码)》这篇文章主要为大家详细介绍了如何使用Python实现一个Excel批量样式修改器,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一... 目录前言功能特性核心功能界面特性系统要求安装说明使用指南基本操作流程高级功能技术实现核心技术栈关键函
阅读更多...
Java实现字节字符转bcd编码

Java实现字节字符转bcd编码

《Java实现字节字符转bcd编码》BCD是一种将十进制数字编码为二进制的表示方式,常用于数字显示和存储,本文将介绍如何在Java中实现字节字符转BCD码的过程,需要的小伙伴可以了解下... 目录前言BCD码是什么Java实现字节转bcd编码方法补充总结前言BCD码（Binary-Coded Decima
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2