实验 二 集合的并、交和差运算C++

合集下载

集合的并交差与补运算

集合的并交差与补运算

集合的并交差与补运算集合是数学中的一个重要概念,在各个领域中都有着广泛的应用。

在集合论中,有几种常见的集合运算,包括并运算、交运算、差运算和补运算。

这些运算可以帮助我们更好地理解集合之间的关系,进而推导出更多有用的结论。

本文将详细探讨集合的并交差与补运算,并展示它们在实际问题中的应用。

一、并运算在集合中,如果将两个集合A和B进行并运算,就是将它们中的所有元素合并成一个新的集合。

并运算通常用符号“∪”表示。

例如,如果集合A={1, 2, 3},集合B={3, 4, 5},那么A∪B的结果就是新的集合{1, 2, 3, 4, 5}。

并运算具有以下性质:1. 交换律:对于任意两个集合A和B,A∪B = B∪A。

即并运算满足元素的无序性。

2. 结合律:对于任意三个集合A、B和C,(A∪B)∪C = A∪(B∪C)。

即并运算满足结合性。

3. 幂等律:对于任意集合A,A∪A = A。

即并运算对于自身的幂等。

二、交运算与并运算类似,交运算是指将两个集合A和B中共有的元素提取出来构成一个新的集合。

交运算通常用符号“∩”表示。

如果集合A={1, 2, 3},集合B={3, 4, 5},那么A∩B的结果就是新的集合{3}。

交运算也具有类似的性质:1. 交换律:对于任意两个集合A和B,A∩B = B∩A。

即交运算满足元素的无序性。

2. 结合律:对于任意三个集合A、B和C,(A∩B)∩C = A∩(B∩C)。

即交运算满足结合性。

3. 幂等律:对于任意集合A,A∩A = A。

即交运算对于自身的幂等。

三、差运算差运算是指将一个集合A中与另一个集合B中相同的元素去除后得到的新集合。

差运算通常用符号“-”表示。

如果集合A={1, 2, 3},集合B={3, 4, 5},那么A-B的结果就是新的集合{1, 2}。

差运算的性质如下:1. 差集的结果只包含属于集合A但不属于集合B的元素。

2. 差运算不满足交换律,即A-B通常不等于B-A。

离散数学c语言程序[离散数学集合运算C或C语言实验报告范文]

离散数学c语言程序[离散数学集合运算C或C语言实验报告范文]

离散数学c语言程序[离散数学集合运算C或C语言实验报告范文]实验成绩:202212202201016学号:【实验题目】1.命题逻辑实验四【实验目的】2.掌握用计算机求集合的交、并、差和补运算的方法。

【实验内容】3.编程实现集合的交、并、差和补运算。

【实验要求】4、++语言编程实现C或C【算法描述】5.10},,,9,6,7,,C,E表示集合。

假定A={1,34,5,(1)用数组AB10},9,,8,7,4,5,6,34B={2,,3,,7,8,10},E={1,2,,输入数据时要求检查数据是否重复(集合中的E(全集),B,输入数组A 的子集。

B是集合E,要求集合数据要求不重复)A,置成空集。

以下每一个运算都要求先将集合CB}且某)二个集合的交运算:AB={某|某A(2C中的元素进行比较,将相同的元素放在数组中元素逐一与数组B把数组AB的交。

便是集合中,数组CA和集合C语言算法:for(i=0;i<m;i++)for(j=0;j<n;j++)if(a[i]==b[j])c[k++]=a[i];B}或某3)二个集合的并运算:AB={某|某A(中中的元素逐一与数组AC中。

将数组B中各个元素先保存在数组把数组AB和集合C便是集合A 的元素进行比较,把不相同的元素添加到数组C中,数组的并。

C语言算法:for(i=0;i<m;i++)c[i]=a[i];for(i=0;i<n;i++){for(j=0;j<m;j++)if(b[i]==c[j])break;if(j==m){c[m+k]=b[i];k++;}}(4)二个集合的差运算:A-B={某|某A且某B}将数组A中的元素逐一与数组B中的元素进行比较,把数组A与数组B不同的元素保存在数组C中,数组C便是集合A和集合B的差A-B。

C语言算法:for(j=0;j<m;j++){for(i=0;i<n;i++){if(A[j]==B[i]){C[k]=A[j];k++;break;}if(j==n){C[k]=A[i];k++;}}A}且~A=B-A={某|某B某)集合的补运算:(5把不相同的元素保存到中的元素进行比较,E中的元素逐一与数组A将数组关于集合中,数组数组CC便是集合AE的补集。

数据结构实验-集合的并交差运算实验报告

数据结构实验-集合的并交差运算实验报告

实验报告实验课程:数据结构实验项目:实验一集合的并交差运算专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(1)实验目的(2)实验任务(3)需求分析二、概要设计:(1)抽象数据类型定义(2)主程序流程(3) 模块关系三、详细设计(1)数据类型及存储结构(2)模块设计四、调试分析(1)调试分析(2)算法时空分析(3)经验体会五、使用说明(1)程序使用说明六、测试结果(1)运行测试结果截图七、附录(1)源代码一、问题定义及需求分析(1)实验目的设计一个能演示集合的并、交、差运算程序。

(2)实验任务1)采用顺序表或链表等数据结构。

2)集合的元素限定为数字和小写英文字母。

(3)需求分析:输入形式为:外部输入字符串;输入值限定范围为:数字和小写英文字母;输出形式为:字符集;程序功能:计算两个集合的交、并、差以及重新输入集合功能;二、概要设计:(1)抽象数据类型定义:线性表(2)主程序流程:调用主菜单函数初始化两个线性表作为集合给两个集合输入数据输出集合数据元素信息另初始化两个线性表创建选择功能菜单界面通过不同选项调用不同功能函数在每个功能函数里面加结束选择功能,实现循环调用功能菜单计算完毕退出程序;(3)模块关系:差运算并运算交运算新建集合结束/返回结束三、详细设计抽象数据类型定义:typedef struct{ElemType *elem;int length;int listsize;}SqList;存储结构:顺序表;模块1-在顺序表的逻辑为i的位置插入新元素e的函数;算法如下:/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1) return 0; //i的合法值为(1 <= i <= L.length_Sq(L) + 1)if(L.length >= L.listsize){ //当前储存空间已满,增加分配newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT) * sizeof(ElemType));if(!newbase) exit(-1); //储存分配失败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; //表长加1return 1;}模块二在顺序线性表L中查找第1个与e满足compare()的元素位序,若找到,则返回其在L中的位序,否则返回0算法如下:/**在顺序线性表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; //从表L中的第一个元素开始与e比较,直到找到L中与e相等的元素时返回该元素的位置if(i <= L.length) return i; //若i的大小小于表长,则满足条件返回ielsereturn 0; //否则,i值不满足条件,返回0}模块三集合交运算算法如下:/**求集合的交集的函数**/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表Lb中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb 中共同的元素放在Lc中}}模块四集合并运算算法如下:/**求集合的并集的函数**/void Union_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length=0; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La 的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}模块五集合的差运算算法如下:/**求集合的差集函数**/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]; //把表La 中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb 中第i个元素赋值给elemif(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}}四、调试分析问题分析及解决:首先,在编写程序时没有设置线性表的初始长度,导致集合元素输入错误;然后通过#define LIST_INIT_SIZE 100和#define LISTINCREMENT 10解决;时空分析:int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))时间复杂度为O(n);Status ListInsert_Sq(SqList &L,int i,ElemType e) 时间复杂度为O(n);void Union_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Mix_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Differ_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(2*m*n);改进设想:当同时求两个以上的结合间的运算是需要先进性两个集合间的运算,然后在于另外的集合进行运算;若要同事进行多个集合的运算需要建立多个顺序表;经验体会:顺序表使用起来比较简单,但长度不可随意变化,适用于大量访问元素,而不适用于大量增添和删除元素;在内存中存储地址连续;五、使用说明第一步:点击运行按钮;第二步: 根据提示输入集合A(可以连续输入,只限输入小写字母和数字);第三步:程序自动显示输入结果;第四步:输入集合B(同第二步);第五步:跳出主菜单界面;第六步:根据选项输入对应运算项的数字序号;第七步:显示运算结果,并可继续进行选择运算还是退出;第八步:若继续运算则返回主菜单,否则退出;第九步:循环第六、七、八步,直至选择退出;六、测试结果输入界面:并运算结果:交运算结果:差运算结果:重新建立集合并运算:七、附录#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 100//初始表空间大小#define LISTINCREMENT 10//表长增量typedef int Status; /**Status是函数类型**/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(-1); /**储存分配失败**/L.length = 0;L.listsize = LIST_INIT_SIZE;/**初始储存容量**/return 1;}/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1)return 0;if(L.length >= L.listsize)//当前储存空间已满,增加分配{newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT )*sizeof(ElemType));if(!newbase) exit(-1);//储存分配失败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;return 1;}/**创建一个线性表,输入数据**/void CreateList_Sq(SqList &L){ElemType ch='\0';int inlist =0,j;while((ch) != '\n'){scanf("%c",&ch);//输入数据for(j = 0; j < L.length; j++)if(ch == L.elem[j])//判断表L中是否有与ch相等的元素 {inlist = 1; //若有,则inlist置1break; //跳出本轮循环}elseinlist =0; //否则inlist为0if(!inlist && ch != '\n')//若inlist为0且ch不为”\n” ListInsert_Sq(L,L.length+1,ch);//则将ch存入表L中 }}/*判断两元素是否相等,若相等则返回1;否则返回0*/Status Equal(ElemType a,ElemType b){if(a == b)return 1;//相等,返回1elsereturn 0;//否则,返回0}/*在顺序线性表L中查找第1个与e满足compare()的元素位序,若找到,则返回其在L中的位序,否则返回0*/int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){ElemType *p;int i;i = 1;p = L.elem;//p的初值为第1个元素的储存位置while(i <= L.length && !(* compare)(*p++,e))//循环查找表L 找出其中与e相等的元素的位置++i;if(i <= L.length)//若i小于表长return i;//则i满足条件,返回i的值elsereturn 0;//否则返回0}/*销毁线性表的函数*/Status Clear_Sq(SqList &L){ElemType elem;free(L.elem);L.elem = NULL;return 1;}/*打印顺序表函数*/void Print_Sq(SqList L){int i;for(i = 0; i < L.length; i++)printf("%2c",L.elem[i]);//通过for循环将表元素全部输出 if(L.length == 0) printf("空集");//若表长为0,则输出空表 printf("\n\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; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}/*求集合的交集的函数*/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表La中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb中共同的元素放在Lc中}}/*求集合的差集函数*/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]; //把表La中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem);//若有,则把elem放入表Lc中,否则,就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb中第i个元素赋值给elem if(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}}void Index_Sq(){//主菜单函数char s;int l=1;InitList_Sq(La);//初始化表Laprintf("\n\t\t 请输入集合A:");CreateList_Sq(La);//创建表Laprintf("\t\t\t集合A为");Print_Sq(La);printf("\n\n");InitList_Sq(Lb);//初始化表Lbprintf("\t\t 请输入集合B:");CreateList_Sq(Lb);//创建表Lbprintf("\t\t\t集合B为");Print_Sq(Lb);printf("\n\n");InitList_Sq(Lc);//初始化表LcInitList_Sq(Ld);//初始化表Ldwhile(l){printf("\t\t ******* 请输入您的操作选项 1、2、3、4. ****** \n\n");printf("\t\t 1、进行集合的并运算\n");printf("\t\t 2、进行集合的交运算\n");printf("\t\t 3、进行集合的差运算\n");printf("\t\t 4、重新建立两个集合\n");printf("\t\t\t");scanf("%c",&s);switch(s){case '1' : system("cls");Union_Sq(La,Lb,Lc);//调用集合的并运算函数printf("\t\t\t集合A与集合B的并集为:");print_Sq(Lc);printf("\n");break;case '2' :system("cls");Mix_Sq(La,Lb,Lc);//调用集合的交集运算函数printf("\t\t\t集合A与集合B的交集为:");print_Sq(Lc);printf("\n");break;case '3' : system("cls");Differ_Sq(La,Lb,Lc);//调用集合的差集运算函数 printf("\t\t\t集合A与集合B的差集为:");print_Sq(Lc);printf("\n");break;case '4' :system("cls");Clear_Sq(La);//销毁表LaClear_Sq(Lb);//销毁表LbClear_Sq(Lc);//销毁表LcClear_Sq(Ld);//销毁表Ldgetchar();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();system("cls");}printf("\n\t\t**************** 谢谢使用!*****************\n");}int main(){printf("\t\t************* 欢迎使用集合操作运算器************\n");Index_Sq();//调用主菜单函数return 0;}。

基于顺序表实现集合的并交差运算实验报告

基于顺序表实现集合的并交差运算实验报告

基于顺序表实现集合的并交差运算实验报告基于顺序表实现集合的并交差运算实验报告⼀实验题⽬: 基于顺序表实现集合的并交差运算⼆实验要求:2.1:编写⼀个程序,实现顺序表的各种基本运算(1)初始化顺序表h ;(2)依次采⽤尾插法插⼊a,b,c,d,e 元素;(3)输出顺序表h(4)输出顺序表h 的长度(5)判断顺序表h 是否为空(6)输出顺序表h 的第三个元素(7)输出元素在a 的位置(8)在第4个元素位置上插⼊f 元素(9)输出顺序表h(10)删除L 的第3个元素(11)输出顺序表(12)释放顺序表2.2:编写⼀个程序,采⽤顺序表表⽰集合(集合中不存在重复的元素),并将其按照递增的⽅式排序,构成有序顺序表,并求这样的两个集合的并,交和差。

三实验内容:3.1 线性表的抽象数据类型:ADT List{数据对象;D=}0,,...,2,1,ElemS et |{≥=∈n n i a a i i数据关系:R1=},...,2,,|,{11n i D a a a a i i i i =∈><--基本操作:InitList(&L)操作结果;构造⼀个空的线性表LDestroyList(&L)初始条件:线性表L 已存在操作结果:销毁线性表LClearList(&L)初始条件:线性表L已存在操作结果:将L置为空表ListEmpty(L)ListLength(L)初始条件:线性表已存在操作结果:返回L中数据元素的个数GetElem(L,i)初始条件:线性表已存在,1<=i<=ListLength(L)操作结果:⽤e返回L中第i个数据元素的值LocateElem(L,i,e)初始条件:线性表已存在,⽤循环遍历整个线性表,如果e与线性表中的元素相同;操作结果:⽤此时的i+1返回该元素在线性表的位序ListInsert(&L,i,e)初始条件:线性表存在,1<=i<=ListLength(L)+1;操作结果:在L中第i个位置之前插⼊新的数据元素,e,L的长度加1。

集合的并交差运算c++

集合的并交差运算c++

集合的并交差运算c++集合的并、交、差运算是集合论中常用的操作,也是编程中常见的操作。

在c++中,可以使用STL中的set容器来实现这些操作。

set是一种有序的容器,其中每个元素都是唯一的。

在set中,插入操作和查找操作的时间复杂度均为O(logN),其中N为集合中元素的个数。

1.并集运算假设有两个set容器A和B,要求它们的并集。

可以使用STL中的set_union函数来实现:set<int> A, B, C; // 定义三个set容器// 将A和B合并为Cset_union(A.begin(), A.end(), B.begin(), B.end(), inserter(C, C.begin()));set_union函数将A和B中的元素合并到C中,并保证C中的元素是有序的且唯一的。

2.交集运算假设有两个set容器A和B,要求它们的交集。

可以使用STL中的set_intersection函数来实现:set<int> A, B, C; // 定义三个set容器// 将A和B的交集放入C中set_intersection(A.begin(), A.end(), B.begin(), B.end(), inserter(C, C.begin()));set_intersection函数将A和B中的共同元素放入C中,并保证C中的元素是有序的且唯一的。

3.差集运算假设有两个set容器A和B,要求它们的差集(即A中有但B中没有的元素)。

可以使用STL中的set_difference函数来实现:set<int> A, B, C; // 定义三个set容器// 将A和B的差集放入C中set_difference(A.begin(), A.end(), B.begin(), B.end(), inserter(C, C.begin()));set_difference函数将A中有但B中没有的元素放入C中,并保证C中的元素是有序的且唯一的。

数据结构课程设计

数据结构课程设计

数据结构课程设计实验1 线性表及其应用1.集合的并、交和差【问题描述】编制一个能演示执行集合的并、交和差运算的程序【基本要求】1)集合的元素限定为小写字母;2)演示程序以用户和计算机的对话方式执行。

void Union(OrderedSet &T,OrderedSet S1, OrderedSet S2){//求已建成的集合Sl和S2的并集T,即:S1.head!=NULL且S2.head!=NULL if(InitList(T){pl=GetEiemPos(Sl,1);p2=GetElemPos(S2,l);while(pl&&p2){cl=Elem(pl); c2=Elem(p2);if(cl<=c2){Append(T,Copy(pl);pl=SuccNode(pl);if(cl==c2) p2=SuccNode(p2);}else{ Append(T,Copy(p2)); p2=SuccNode(p2); }while(pl){ Append( T,Copy(pl)); pl=SuccNode(pl);}while(p2){Append(T,Copy(p2)); p2=SuccNode(p2);}}}//Unionvotd Intersection(OrderedSet &T,OrderedSet S1; OrderedSet S2) {//求集合 Sl 和 S2 的交集 Tif(!InitList(T)) T.head =NULL;else{pl=GetElemPos(S1,1);p2=GetElemPos(S2,l);while(pl&&p2){c1=Elem(p1);c2=Elem(p2);if(cl<c2) pl=SuccNode(pl);else if(cl>c2) p2=SuccNode(p2);else{ //cl==c2Append(T,Copy(pl));pl=SuccNode(pl);p2=SuccNode(p2);}//else}//while}// else}//Intersectionvoid Difference(OrderedSet &T,OrderedSet S1,OrderedSet S2) {//求集合Sl和S2的差集Tif(!InitList(T)) T.head =NULL;else {pl =GetElemPos(S1,l);p2=GetElemPos(S2,1);while(pl&&p2){cl=Elem(pl);c2=Elem(p2);if(cl<c2){Append(T,Copy(pl));pl=SuccNode(pl)else if(cl>c2) p2=SuccNode(p2);else // Cl ==c2{pl =SuccNode(p1);p2=SuccNode(p2);}}//whilewhile(pl){Apend(T,Copy(pl));p =SuccNode(pl);}}//else}//Differencevoid WriteSetElem(LinkType p){//显示集合的一个元素pramtk'Jh WriteElem(Elem(p));}//WriteSetElemvotd Printset(OrderedSet T){//显示集合的全部元素p=GetElemPos(T,1);printf('[']);if(p){WriteElem(Elem(p);p=SuccNode(p);}ListTraverse(p,WriteSetElem());Prtntf(')]');}//Printset实验2 栈、队列和递归程序设计2. 迷宫问题。

离散数学(集合的运算)实验报告

离散数学(集合的运算)实验报告

大连民族学院计算机科学与工程学院实验报告实验题目:集合的运算课程名称:离散数学实验类型:□演示性□验证性□操作性□设计性□综合性专业:网络工程班级:网络111班学生姓名:张山学号:2011083123实验日期:2013年12月22日实验地点:I区实验机房实验学时:8小时实验成绩:指导教师签字:年月日老师评语:实验题目:集合的运算实验原理:1、实验内容与要求:实验内容:本实验求两个集合间的运算,给定两个集合A、B,求集合A与集合B之间的交集、并集、差集、对称差集和笛卡尔乘积。

实验要求:对于给定的集合A、B。

用C++/C语言设计一个程序(本实验采用C++),该程序能够完成两个集合间的各种运算,可根据需要选择输出某种运算结果,也可一次输出所有运算结果。

2、实验算法:实验算法分为如下几步:(1)、设计整体框架该程序采取操作、打印分离(求解和输出分开)的思想。

即先设计函数求解各部分运算并将相应结果传入数组(所求集合)中,然后根据需要打印运算结果。

(2)、建立一个集合类(Gather)类体包括的数组a、b、c、d、e、f、g分别存储集合A、B以及所求各种运算的集合。

接口(实现操作的函数)包括构造函数,菜单显示函数,求解操作函数,打印各种运算结果等函数。

(3)、设计类体中的接口构造函数:对对象进行初始化,建立集合A与集合B。

菜单显示函数:设计提示选项,给使用者操作提示。

操作函数:该函数是程序的主题部分,完成对集合的所有运算的求解过程,并将结果弹入(存入)对应数组(集合)中,用于打印。

具体操作如下:1*求交集:根据集合中交集的定义,将数组a、b中元素挨个比较,把共同元素选出来,并存入数组c(交集集合)中,即求得集合A、B的交集。

2*求并集:根据集合中并集的定义,先将数组a中元素依次存入数组g(并集集合)中,存储集合A中某元素前,先将其与已存入g中的元素依次比较,若相同则存入下一个元素,否则直接存入g中,直到所有A中元素存储完毕。

用java编程实现集合的交、并、差和补运算

用java编程实现集合的交、并、差和补运算

⽤java编程实现集合的交、并、差和补运算⼀、实验⽬的掌握集合的交、并、差和补运算,并且使⽤计算机编程实现。

⼆、实验内容通过编程实现求给定集合A和B的并集C(C=A∪B)、交集C(C=A∩B)、差集C(C=A-B)、补集~C=E-C的运算。

三、实验要求C、C++或Jave语⾔编程实现四、实验原理1、根据交集的定义:C={x | x∈A∧x∈B},我们将集合A的各个元素与集合B的元素进⾏⽐较,若在集合B中存在某个元素和集合A中⼀元素相等,则将该元素送⼊交集C之中。

2、并集的定义为:C={x|x∈A∨x∈B},所以,只要将集合A与B合在⼀起就得到了并集C。

但是,在⼀个集合中,同样的元素没必要出现两次或两次以上,所以,在将集合A送⼊并集C后,应将集合B中与A中相同的元素删除,再将集合B送⼊并集C之中。

3、差集C的定义:差集C={x|x∈A∧xB},即对于集合A中的元素ai,若不存在bj∈B(j=1,2,…..,m),使得ai=bj,则ai ∈差集C。

4、补集C的定义:~C=E-C={ x|x∈E∧xC }五、实验过程源代码package cn.sal.lisan;import java.util.HashSet;import java.util.Set;import java.util.Scanner;public class Bingjiao {public static void main(String[] args) {Set<Integer> result = new HashSet<Integer>();Set<Integer> A = new HashSet<Integer>();Set<Integer> B = new HashSet<Integer>();Set<Integer> E=new HashSet<Integer>();//以上是为了为四个集合开辟内存空间,⽅便后续赋值System.out.println("请先输⼊A,B,E每个集合的元素个数,然后依次输⼊集合中的元素");Scanner scanner=new Scanner(System.in);//获取控制台输⼊int x=scanner.nextInt();//获取A集合的元素个数int y=scanner.nextInt();//获取B集合元素个数int z=scanner.nextInt();//获取E集合元素个数// int[] a=new int[x];for(int i=0;i<x;i++){int i1=scanner.nextInt();A.add(i1);}//为A集合赋值for(int j=0;j<y;j++){int j1=scanner.nextInt();B.add(j1);}//为B集合赋值for(int k=0;k<z;k++){int k1=scanner.nextInt();E.add(k1);}System.out.println("E ="+E.toString());System.out.println("A = "+A.toString());System.out.println("B = "+B.toString());result.clear();//清除result中的元素result.addAll(A);//将A集合中的元素放⼊result中result.retainAll(B);//去除A中的所有不在B中的元素System.out.println("交集 = " + result);result.clear();result.addAll(A);result.removeAll(B);//清除A中所有属于B的元素System.out.println("差集 = "+result);result.clear();result.addAll(A);result.addAll(B);//把A,B中的元素都加⼊进去,⽽且set中不会有重复的元素 System.out.println("并集 = " + result);result.clear();result.addAll(E);result.removeAll(A);//跟差集⼀样System.out.println("补集 ="+result);}}实验结果请先输⼊A,B,E每个集合的元素个数,然后依次输⼊集合中的元素2 4 51 21 3 4 51 2 3 4 5E =[1, 2, 3, 4, 5]A = [1, 2]B = [1, 3, 4, 5]AB交集 = [1]AB差集 = [2]AB并集 = [1, 2, 3, 4, 5]AB补集 =[3, 4, 5]实验总结总结:因为这次离散实验可以⽤java写,⽽java中HashSet类恰好有add() remove()等⽅法直接⽤来计算集合的并集,交集,差集,所以本次实验就使⽤java语⾔来完成了,这次实验利⽤了set类的特性,即不会出现相同的元素,和集合定义相符合,该题的思路是,利⽤scanner类获取⽤户的输⼊值,然后利⽤set类的add⽅法,将⽤户输⼊的集合元素全部放⼊相应的集合中,此后,具体到求交集并集差集时,先引⼊第三个变量result作存储(引⼊第三⽅是为了不改变已定义好的集合的值),在计算交集时,先⽤addall⽅法把A集合全部放⼊result中,然后result调⽤retainAll(B)⽅法,保留result中存在B中的元素,同样,计算并集时,⽤addAll⽅法,把A和B集合都放在result中,利⽤set不允许集合出现重复元素特性,可得到A和B的并集,在求差集时,调⽤removeAll⽅法,可除去A中存在B中的元素,在求补集时,也是利⽤差集思想,去除E中存在A中的元素。

集合的交并差补与代数的加减乘除

集合的交并差补与代数的加减乘除

集合的交并差补与代数的加减乘除wsyAugust13,2015我们都知道,集合的运算和代数的运算是独立的,一般没有太大的关联。

集合的基本的运算法则有:•交集:A B;•并集:A B;•补集:A;•差集:A−B.但是,我们通过如下的定义,可以建立一个集合的代数运算关系:令全集Ω表示为1,空集∅表示为0•交集:A∩B=ab;•并集:A∪B=a+b−ab;•补集:A=1−a;•差集:A−B=A−A∩B=a−ab=a(1−b).其中,集合A,B在代数运算中,用相应的小写字母a,b表示。

注意到,因为A∩A=A,所以根据定义可以推导出,我们的定义满足幂等律a·a=a2=a.除了,这一点有差异之外,其它运算与代数运算都相同。

接下来,我们可以看到,集合的对偶律和结合律,使用上述定义之后,也是吻合的。

下列代数式子在化简后是显然成立的,我们减去了化简的步骤。

1.对偶律:1•对于A∩B=A∪B,代入上述定义,有1−ab=(1−a)+(1−b)−(1−a)(1−b).•对于A∪B=A∩B,代入上述定义,有1−(a+b−ab)=(1−a)(1−b).2.结合律:•对于(A∩B)∪C=(A∪C)∩(B∪C),代入上述定义,有ab+c−abc=(a+c−ac)(b+c−bc).•对于(A∪B)∩C=(A∩C)∪(B∩C),代入上述定义,有(a+b−ab)c=ac+bc−ac·bc.综上可知,我们的定义是满足集合运算的要求的。

之所以要把集合的运算,转化为代数的运算,是因为一般的人,对于代数运算的熟悉程度远远高于集合运算。

这为我们验证,求解,推断复杂的集合运算的式子提供了另外的一种新的更加简便快速的方式。

2。

集合运算及关系运算

集合运算及关系运算

实验二集合运算及关系运算1、实验目的集合是一切数学的基础,每一门数学的讨论都离不开集合,为此,我们必须掌握集合的基本定义及运算规律,掌握集合的运算规则对与学习离散数学将有着极大的帮助。

本实验通过编写一个C++程序,让计算机来完成两个集合的交、并、差、笛卡儿积及子集及简单关系运算。

目的是让同学们更加深刻的理解集合的运算规则,特别是集合的笛卡儿积运算是我们接触的一个新的集合运算规则。

2、实验内容与要求集合的运算及关系的运算:⏹交运算:设A,B是两个集合,则A∩B={x|(x A)并且(x B)}⏹并运算:设A,B是两个集合,则A∪B={x|(x A)或(x B)}⏹差运算:设A,B是两个集合,则A-B={x|(x A)并且(x B)}⏹笛卡儿集合:设A,B是两个集合,称集合A×B={<x,y>|(x A)∧(y B)}为集合A与B的笛卡儿积⏹求关系合成运算:设R是X到Y的关系,S是Y到Z的关系,则RοS称为R和S的复合关系,定义为:RοS= { <x,z>∃∣y(<x,y>∈R∧<y,z>∈S)}要求依据上述运算规则,实现任意给定两个集合的交、并、差、笛卡儿积运算,求幂集求关系的合成运算并显示运算结果。

3、实验步骤3.1A交B首先定义a[],b[],c[]三个数组,分别表示为A,B集合的输入及其操作后的集合,int length1=0,length2=0,clength=0;int a[100],b[100],c[100];交集的实现主要是设立一个标志flag=0,如果集合A中的元素和集合B中的元素相等,则flag标记为1,并将标记为1的元素赋值到C集合中去,则得到集合A与B的交集int flag1=0;for(int i=0;i<length1;i++){int flag1=0;for(int j=0;j<length2;j++) {if(a[i]==b[j]){flag1=1;break;}}if(flag1==1)c[clength++]=a[i];continue;}3.2A并B设置标志flag2,以及并集数组c1[].首先将集合A中的数全都赋给集合C,同理要利用标志flag2,如果集合A中的元素与集合B中的元素相等,则flag2标志为1,并将b[]中的其他不与a[]中相等的元素接着赋值给c1[],则此时c1[]即为集合A与集合B的并集。

编制一个演示集合的并、交和差运算的程序实习报告

编制一个演示集合的并、交和差运算的程序实习报告

编制一个演示集合的并、交和差运算的程序实习报告题目:编制一个演示集合的并、交和差运算的程序一、需求分析1. 本演示程序中,集合的元素限度为小写字母字符【‘a’..‘z’】,集合的大小n<27,集合输入的形式为一个以“回车符”为结果标志的字符串,串中字符顺序不限,且允许出现重复字符或非法字符,程序应能自动滤去。

输出的运算结果字符串中将不含重复字符或非法字符。

2. 演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运算命令;相应的输入数据(滤去输入中的非法字符)和运算结果显示在其后。

3. 程序执行的命令包含:1)构造集合1;2)构造集合2;3)构造求并集;4)求交集;6)结束。

“构造集合1”和“构造集合2”时,需以字符串的形式键入集合元素。

4. 测试数据(1)Set1=”magazine”,Set2=”paper”,Set2 set2=”aegimnprz”,二、概要设计为实现上述程序功能,应以有序链表表示集合。

为此,需要两个抽象数据类型;有序表和集合。

1、有序表的抽象数据类型定义为:ADT ORDERDElist{数据对象:D={ai|ai∈CharSet,i=1,s,...n,n>=0}数据关系:R1={}基本操作:InitList(&L)操作结果:构造一个空的有序表L。

DestroyList(&L)初始条件:有序表L已存在。

操作结果:销毁有序表L。

ListLength(L)初始条件:有序表L已存在。

1.有序表的抽象数据类型定义为操作结果:返回有序表L的长度。

ListEmpty(L)初始条件:有序表L已存在。

操作结果:若有序表L为空表,则返回True,否则返回False。

GetElem(L,pos)初始条件:有序表L已存在。

操作结果:若1<=pos<=Length(L),则返回表中第pos个元素。

集合的并、交和差运算

集合的并、交和差运算

集合的并、交和差运算
引言
在数学中,集合是由若干个元素组成的。

当我们处理集合时,会遇到三种基本的集合运算:并、交和差运算。

本文将介绍这三种运算的定义和性质。

集合的并运算
集合的并运算(union)指的是将两个或多个集合的所有元素合并成一个集合。

用符号∪表示。

对于给定的集合 A 和集合 B,它们的并集 A ∪ B 是包含了 A 和 B 中所有元素的集合。

集合的交运算
集合的交运算(intersection)指的是找到两个或多个集合中共有的元素,并将它们组成一个新的集合。

用符号∩ 表示。

对于给定的集合 A 和集合 B,它们的交集A ∩ B 是包含了 A 和 B 共有元素的集合。

集合的差运算
集合的差运算(difference)指的是从一个集合中减去另一个集合的元素,得到一个新的集合。

用符号 - 表示。

对于给定的集合 A 和集合 B,它们的差集 A - B 是包含了属于 A 但不属于 B 的元素的集合。

总结
通过并、交和差运算,我们可以对集合进行各种组合操作。

并集合并了两个或多个集合的元素,交集找到了两个或多个集合的共有元素,差集减去了一个集合中属于另一个集合的元素。

这些运算为我们处理集合提供了灵活性和多样性。

请注意,集合运算中的元素不会重复出现。

对于重复元素的处理,我们可以使用集合的扩展运算或计数运算进行处理。

参考资料
- 集合运算的定义和性质,《高等数学教程》
- 集合运算的应用,《离散数学》。

C语言实现集合的交,并,差

C语言实现集合的交,并,差
DelFirst(lsb,node);Append(lsc,node);
}
return OK;
}
Status IntersectionSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{
//已知集合ls1,ls2的元素按值非递减排列
//将集合ls1,ls2的交集到ls3
ls.tail = (Link) malloc( sizeof(Link));
if(!ls.head || !ls.tail) exit(OVERFLOW); //如果分配失败
ls.head->next = ls.tail->next = NULL; //头、尾指针为空
ls.len = 0; //长度为0
int result = Compare(pa,pb);
if( result<0) ...{
DelFirst(lsa,node);pa = NextPos(ha);
}else if(result>0)...{
DelFirst(lsb,node); pb = NextPos(hb);
}else...{
}
return OK;
}
Status DifferenceSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{
//已知集合ls1,ls2的元素按值非递减排列
//ls3 = ls1 - ls2
if( !InitSe h->next;
}
printf(" ] ");
return OK;
}

离散数学---集合的基本运算

离散数学---集合的基本运算

E
A
B
广义的并集
集合的并(union):集合A和B的并AB定义 为:AB = {x | xA或者xB},集合的并可 推广到多个集合,设A1, A2, …, An都是集合, 它们的并定义为:
A1A2∪…An = {x | 存在某个i,使得xAi}
广义的交集
集合的交(intersection):集合A和B的并AB定义 为:AB = {x | xA而且xB},集合的交也可推广 到多个集合,设A1, A2, …, An都是集合,它们的交 定义为:
集合的化简
化简((ABC)(AB))-((A(B-C))A) 证明:原集合=(AB)-A(吸收律)
=(AB)A =(AA)(BA)(分配律)
=(BA) =BA
(互补律) (同一律)
集合包含的性质
• AE •如果ABC,则AC •ABAA∪B •AB A∪B=B AB=A ~B ~A
利用集合等式证明
求证:A-(B∪C)=(A-B)∩(A-C)
(A-B)∩(A-C)=A∩~B∩A∩~C =A∩~B∩~C =A∩~(B∪C) =A-(B∪C)
证明吸收律A(AB)=A
证明:A(AB) =(A)(AB) =A(B) =A =A
已知AB=AC,AB=AC,求证B=C
6、零一律 A∩=,A∪E=E
(A∩B)=A∪B
7、补余律 A∩A=,A∪A=E
10、双重否定律(A)=A
8、吸收律 A∪(A∩B)=A
注:A-B=A∩B
A∩(A∪B)=A
集合相等的证明的方法
一、利用集合的定义证明; 二、利用集合等式证明;(常用) 三、利用谓词公式证明; 四、用集合成员表。(略)
即AB={xxA且x BxB且x A}

集合的并、交和差运算精品文档9页

集合的并、交和差运算精品文档9页

实验报告题目:集合的并、交和差运算班级:班姓名:学号:1.需求分析设计一个程序,要求实现集合的并、交和差运算(1)输入的形式为字符型或者整型,输入的范围:小写字母字符。

输出的形式:字符型或者整型。

(2)程序所能达到的功能:实现集合的并、交和差运算(3)测试数据:正确:set1=”magazine”,set2=”paper”set1∪set2=”aegimnprz”,set1∩set2=”ae”,set1-set2=”gimnz”。

错误:set1=”012oper4a6tion89”,set2=”error data”set∪set2=”adeinoprt”,set1∩set2=”aeort”,set1-set2=”inp”。

2.概要设计为实现上述程序功能,应以有序链表表示集合。

为此,需要两个抽象数据类型:有序表和集合(1)有序表的抽象数据类型定义为:ADT OrderedList{数据对象:D={ ai丨ai∈CharSet,i=1,2,…,n>=o}数据关系:R1={ < ai-1,ai>丨ai-1,ai∈D,ai-1<ai,i=2,…,n}基本操作:InitList(&L) // 结构初始化LocateElem(L, e, compare()) // 查找ListInsert(&L, i, e) // 插入元素ListDelete(&L, i,&e) // 删除元素等。

(2) 集合的抽象数据类型定义为:ADT Set{数据对象:D={ai丨ai为小写英文字母且互不相同,i=1,2,…,n,0<=n<=26}数据关系:R1={}基本操作:CreatSet(&T,Str) //生成集合TDestroySet(&T ) //销毁集合T的结构。

等。

各程序模块之间用for循环和while语句来实现调用。

3.调试分析:调试过程中遇到的一些问题是通过网络查询,咨询老师等来解决。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验二集合的并、交和差运算// 在写代码的过程中,没有注意头结点~~~ 导致出现了很多野指针~~~ ,几乎重写. 。

o 0 ~~~// 经同学检查,发现有错误~~~ 红色部分代码已经修正//集合的并、交和差运算/*选作内容(1)集合元素的判定和子集判定运算(2)求集合的补集(3)集合的混合式运算表达求值(4)集合的元素类型推广到其他类型,甚至任意类型*//*测试数据:(1)Set1 ="magazine",Set2 ="paper",Set1∪Set2 ="aegimnpra",Set1∩Set2 ="ae",Set1 - Set2 ="gimnz"(2)Set1 =012oper4a6tion89",Set2 ="error date",Set1∪Set2 ="adeinoprt",Set1∩Set2 ="aeort",Set1 - Set2 ="inp"*/#include<iostream>#include<cstdlib>#include<cstdio>using namespace std;#define Elem Type chartypedef struct ElemNode{Elem Type elem;struct ElemNode *next;}ElemNode, *Set;//-------------FunctionList------------------------------//---------------函数原型--------------------------------int LengthOf(Set src);//返回一个集合的长度void CreateSet(Set dest);//创建一个新的字母集合,限定a-zvoid EmptySet(Set dest);//清空一个集合,保留头结点void DestroySet(Set dest);//销毁集合void SortSet(Set dest);//对一个集合进行从小到大的排序void DisplaySet(Set src);//打印集合的所有元素int ExistElem(Set dest, Elem Type e);//判断元素是否存在于集合中void DelElem(Set dest, ElemType e);//删除集合中的一个元素一次void AddElem(Set dest, Elem Type e);//在链表尾部追加一个元素void ContactSet(Set dest, Set src);//连接一个集合到另一个集合void AddSet(Set dest, Set src1, Set src2);//集合并运算void MulSet(Set dest, Set src1, Set src2);//集合交运算void SubSet(Set dest, Set src1, Set src2);//集合差运算int ExistSubset(Set dest, Set src);//子集判断void NegSet(Set dest, Set src);//求补集int m ain(){Set dest=(Set)m alloc(sizeof(ElemNode));Set src1=(Set)m alloc(sizeof(ElemNode));Set src2=(Set)m alloc(sizeof(ElemNode));dest->next=NULL;cout<<"输入两个集合:"<<endl;CreateSet(src1);CreateSet(src2);cout<<endl;cout<<"Set1 =";DisplaySet(src1);cout<<"\t";cout<<"Set2 =";DisplaySet(src2);cout<<endl<<endl;int item;cout<<"1->集合并"<<" "<<"2->集合交"<<" "<<"3->集合差"<<" "<<"非零整数->错误!重输"<<" "<<"0->进入下一步演示"<<endl;while(cin>>item){if(item)switch(item){case 1: cout<<"集合并运算:Set1∪Set2 =";AddSet(dest, src1, src2);DisplaySet(dest);Em ptySet(dest);cout<<endl;break;case 2: cout<<"集合交运算:Set1∩Set2 =";MulSet(dest, src1, src2);DisplaySet(dest);Em ptySet(dest);cout<<endl;break;case 3: cout<<"集合差运算:Set1-Set2 =";SubSet(dest, src1, src2);DisplaySet(dest);Em ptySet(dest);cout<<endl;break;default: cout<<"输入错误!重输!!!"<<endl;break;}else {cout<<"进入下一步演示..."<<endl;break;} // 此处在VC++ 6.0 运行与CFree 中有点不同(在CFree中要按下回车~~~)}getchar();cout<<"输入一个集合:"<<endl;CreateSet(dest);cout<<"原集合为:";DisplaySet(dest);cout<<endl<<endl;char ch;cout<<"在链表尾部添加一个元素ch =";cin>>ch;AddElem(dest, ch);DisplaySet(dest);cout<<endl<<endl;cout<<"删除集合中的存在的某个元素ch ="; cin>>c h;DelElem(dest, ch);DisplaySet(dest);cout<<endl<<endl;cout<<"再创建一个集合src =";Set src=(Set)malloc(sizeof(ElemNode));getchar();CreateSet(src);cout<<"将src集合链接到集合dest中..."<<endl;ContactSet(dest, src);cout<<"此时dest为:";DisplaySet(dest);cout<<endl;if(ExistSubset(dest, src))cout<<"此时src是dest的子集..."<<endl;elsecout<<"此时src不是dest的子集..."<<endl;cout<<endl<<"dest =";DisplaySet(dest);cout<<endl;cout<<"dest的补集是:";Set p=(Set)m alloc(sizeof(ElemNode));p->next=NULL;NegSet(p, dest);DisplaySet(p);cout<<endl<<"演示结束!!!"<<endl;DestroySet(dest);return 0;}//---------------BasicFunctions----------------------- //------------------函数实现-------------------------- int LengthOf(Set src){//返回一个集合的长度int i=0;while(src->next!=NULL){i++;src=src->next;}return i;}//LengthOfvoid CreateSet(Set dest){//创建一个新的字母集合,限定a-zElem Type ch;Set p=dest,n;for(;;){ch=getchar();if(ch=='\n') break;if(ch<97||ch>122) continue;n=(Set)m alloc(sizeof(ElemNode)); p->next=n;n->elem=c h;n->next=NULL;p=n;}return ;}//CreateSetvoid EmptySet(Set dest){//清空一个集合,保留头结点Set p,n;while(dest->next!=NULL){p=dest;n=p->next;for(;n->next!=NULL;){p=n;n=n->next;}free(n);p->next=NULL;}}//EmptySetvoid DestroySet(Set dest){//销毁集合Em ptySet(dest);free(dest);}//DestroySetvoid SortSet(Set dest){//对一个字母集合进行从小到大的排序 int i,j,l,flag;Set p,q,n;l=LengthOf(dest);if(l<2) return;flag=1;for(i=l-1;i>0&&flag==1;i--) {flag=0;p=dest;q=p->next;n=q->next;for(j=0;j<i;j++){if(q->elem>n->elem){flag=1;p->next=n;q->next=n->next;n->next=q;q=p->next;n=q->next;}p=q;q=n;n=n->next;}}}//SortSetvoid DisplaySet(Set src) {//打印集合的所有元素Set p;if(src->next==NULL){printf("φ");return ;}p=src;dop=p->next;putchar(p->elem);} while(p->next!=NULL);}//DisplaySetint ExistElem(Set dest, Elem Type e) {//判断元素是否存在于集合中Set p=dest;if(LengthOf(p)==0)return 0;else{p=p->next;while(p->elem!=e){if(p->next==NULL)return 0;p=p->next;}return 1;}}//ExistElemvoid DelElem(Set dest, ElemType e) {//删除集合中的一个元素一次Set p=dest,q;if(LengthOf(p)==0)return ;q=p->next;if(LengthOf(p)==1){p->next=NULL;free(q);}while(q->elem!=e){p=p->next;q=q->next;if(q->next==NULL){p->next=NULL;free(q);}elsep->next=q->next;}//DelElemvoid AddElem(Set dest, Elem Type e){//在链表尾部追加一个元素Set p=dest, n;while(p->next!=NULL)p=p->next;n=(Set)m alloc(sizeof(ElemNode));p->next=n;n->elem=e;n->next=NULL;}//AddElemvoid ContactSet(Set dest, Set src){//连接一个集合到另一个集合Set p=dest;while(p->next!=NULL)p=p->next;p->next=src->next;}//ContactSetvoid AddSet(Set dest, Set src1, Set src2){//集合并运算SortSet(src1);SortSet(src2);int i=0,j=0,len1=LengthOf(src1),len2=LengthOf(src2); src1=src1->next;src2=src2->next;while(i<len1&&j<len2){if(src1->elem<=src2->elem){i++;if(!ExistElem(dest, src1->elem)) {AddElem(dest, src1->elem);src1=src1->next;}else{src1=src1->next;}}else{j++;if(!ExistElem(dest, src2->elem)) {AddElem(dest, src2->elem);src2=src2->next;}else{src2=src2->next;}}}while(i<len1){i++;if(!ExistElem(dest, src1->elem)) {AddElem(dest, src1->elem);src1=src1->next;}}while(j<len2){j++;if(!ExistElem(dest, src2->elem)){AddElem(dest, src2->elem);src2=src2->next;}}}//AddSetvoid MulSet(Set dest, Set src1, Set src2){//集合交运算SortSet(src1);SortSet(src2);int i=0,j=0,len1=LengthOf(src1),len2=LengthOf(src2);src1=src1->next;src2=src2->next;while(i<len1&&j<len2){if(src1->elem<src2->elem) {i++;src1=src1->next;}else if(src1->elem>src2->elem) {j++;src2=src2->next;} else{i++;j++;if(!ExistElem(dest, src1->elem)){AddElem(dest, src1->elem);src1=src1->next;src2=src2->next;}}}}//MulSetvoid SubSet(Set dest, Set src1, Set src2){//集合差运算SortSet(src1);SortSet(src2);int i=0,len=LengthOf(src1);src1=src1->next;while(i<len){i++;if(!ExistElem(src2, src1->elem))if(!ExistElem(dest, src1->elem)) {AddElem(dest, src1->elem);src1=src1->next;}}else{src1=src1->next;}}}//SubSetint ExistSubset(Set dest, Set src) {//子集判断int i=0,len=LengthOf(src);src=src->next;while(i<len){if(!ExistElem(dest, src->elem)) return 0;i++;src=src->next;}return 1;}//ExistSubsetvoid NegSet(Set dest, Set src) {//求补集SortSet(src);int i=0;while(i<26){if(!ExistElem(src, i+97))AddElem(dest, i+97);i++;}//NegSet 运行示意图:。

相关文档
最新文档