集合 的交并和差的运算与实现

大数据的交并差计算是数据分析和处理中的重要步骤，主要用于处理集合运算。

交集运算是指从两个或多个集合中共同拥有的元素组成的集合。

在大数据环境下，交集运算可以通过对各个集合进行逐一比较来实现。

具体来说，对于两个集合A和B，它们的交集可以表示为A∩B，即包含A和B 中共同拥有的元素。

并集运算是指将两个或多个集合中的所有元素合并到一个新的集合中。

在大数据环境下，并集运算可以通过对各个集合进行合并操作来实现。

具体来说，对于两个集合A和B，它们的并集可以表示为A∪B，即包含A 和B中的所有元素。

差集运算是指从一个集合中去除另一个集合中的元素后得到的集合。

在大数据环境下，差集运算可以通过对两个集合进行逐一比较和排除操作来实现。

具体来说，对于两个集合A和B，它们的差集可以表示为A-B或AΔB，即包含A中存在但B中不存在的元素。

班级：计算机11-3班学号：姓名：曲玉昆成绩：_________实验四集合的交、并和差运算的实现1. 问题描述用有序单链表表示集合，实现集合的交、并和差运算。

2. 基本要求⑴对集合中的元素，用有序单链表进行存储；⑵实现交、并、差运算时，不另外申请存储空间；⑶充分利用单链表的有序性，算法有较好的时间性能。

3. 设计思想AB。

单链表的结点结构和建立算法和首先，建立两个带头结点的有序单链表表示集合请参见教材，需要注意的是：利用头插法建立有序单链表，实参数组应该是降序排列。

其次，根据集合的运算规则，利用单链表的有序性，设计交、并和差运算。

AB的元素。

又属于集合⑴根据集合的运算规则，集合中包含所有既属于集合BA?因此，需查找单链表A和B中的相同元素并保留在单链表A中。

算法如下：的元素。

BA或属于集合中包含所有或属于集合⑵根据集合的运算规则，集合B?A xx不相同的元素，则中进行查找，若存在和B中的每个元素，在单链表A因此，对单链表A中。

算法请参照求集合的交集自行设计。

将该结点插入到单链表的元素。

因而不属于集合AB根据集合的运算规则，集合⑶ A-B中包含所有属于集合xx相同的结点，则将该中进行查找，若存在和AB此，对单链表中的每个元素，在单链表中删除。

算法请参照求集合的交集自行设计。

A结点从单链表．template<class T>struct Node{T data;Node<T>*next;};template <class T>class LinkList{public:LinkList(T a[],int n);//建立有n个元素的单链表~LinkList();void Interest(Node<T> *A, Node<T> *B);//求交集void Sum(Node<T> *A,Node<T> *B);/void Subtraction(Node<T> *A,Node<T> *B);void PrintList();void Show(int i);Node<T> *first;};template<class T>LinkList<T>::LinkList(T a[],int n){Node<T>*s;first = new Node<T>;first->next=NULL;for(int i=0;i<n;i++){s = new Node<T>;s->data=a[i];s->next=first->next;first->next=s; }}template <class T>LinkList<T>::~LinkList(){Node<T> *p,*q;p = first;//工作指针p初始化while(p) //释放单链表的每一个结点的存储空间{q = p;//暂存被释放结点p = p->next;//工作指针p指向被释放结点的下一个结点，使单链表不断开 delete q; }}template<class T>void LinkList<T>::Interest(Node<T> *A,Node<T> *B){Node<T> *pre,*p,*q;re = A;p =A ->next;q = B->next;pwhile(p&&q){if(p->data < q->data){pre->next = p->next;p = pre->next;}else if(p->data > q->data){q = q->next;}else{pre = p;p = p->next;q = q->next;} }}//求并集template<class T>void LinkList<T>::Sum(Node<T> *A,Node<T> *B{Node<T> *pre,*p,*q;pre = A; p = A->next;q = B->next;while(p&&q){if(p->data < q->data){pre = p;p = p->next;}else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = p->next;q = q->next;}}}template<class T>void LinkList<T>::Subtraction(Node<T> *A,Node<T> *B){ Node<T> *pre,*p,*q,*pra;pre = A; pra = B; p = A->next; q = B->next;while(p&&q){if(p->data < q->data){pre = p;p = p->next; }else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = pre->next;q = q->next;}}}template<class T>void LinkList<T>::PrintList(){Node<T> *p;p=first->next;//工作指针p初始化while(p != NULL)//遍历输出所有元素{cout<<p->data;p = p->next; }cout<<endl;}//菜单函数int meun(){int m;do {c畯?尼请输入对应数字(1、求交集2、求并集3、求差集4、结束运行)<<endl; cin>>m;}while(m<1||m>4);return m;}int a[]={5,4,3,2,1},b[]={6,4,2};int n = 5,m = 3;LinkList<int> SL(a,n);LinkList<int> sl(b,m);LinkList<int> s(a,n);LinkList<int> S(b,m);LinkList<int> l(a,n);LinkList<int> L(b,m);static bool bl = true;template<class T>void LinkList<T>::Show(int i){switch(i) {case 1:{Node<T> *p,*q;p = ;q = ;();();(p,q);();cout<<endl;<<endl;}break;已求交集潣瑵?case 2:{Node<T> *p,*q;p = ;q = ;();();(p,q);();();潣瑵?已求并集<<endl;}break;case 3:{Node<T> *p,*q;p = ;q = ;();();(p,q);();潣瑵?已求差集<<endl;}break;case 4:{bl = false; } break; }}void main(){while(bl == true){int i=meun();(i);}}。

实验报告实验课程：数据结构实验项目：实验一集合的并交差运算专业：计算机科学与技术班级：姓名：学号：指导教师：目录一、问题定义及需求分析（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。

大连民族学院计算机科学与工程学院实验报告实验题目：集合的运算课程名称：离散数学实验类型：□演示性□验证性□操作性□设计性□综合性专业：网络工程班级：网络111班学生姓名：张山学号：2011083123实验日期：2013年12月22日实验地点：I区实验机房实验学时：8小时实验成绩：指导教师签字：年月日老师评语：1实验题目：集合的运算实验原理：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。

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

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

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

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

关系数据库的集合运算
关系数据库的集合运算包括交（intersection）、并（union）、差（difference）和联结（join）。

1. 交（Intersection）：取两个关系的交集，即在两个关系中都存在的元组组成的关系。

2. 并（Union）：取两个关系的并集，即包含两个关系中所有元组的关系。

3. 差（Difference）：取第一个关系与第二个关系的差集，即只包含第一个关系中存在的元组的关系。

4. 联结（Join）：连接两个关系，得到一个新的关系。

两个关系的连接是基于它们之间的公共属性进行的，也称为自然连接。

以上四种关系集合运算是数据库管理系统中最基本也是最常用的操作。

通过这些基础的运算，可以灵活地操作数据库中的数据，进行各种查询和分析。

使⽤单链表来实现集合的交并差运算数据结构使⽤单链表来实现集合的交并差运算数据结构问题描述该算法的设计，要求运⾏结果如下所⽰：集合的运算如下:原集合A: c a e h原集合B: f h b g d a有序集合A: a c e h有序集合B: a b d f g h集合的并C: a b c d e f g h集合的交C: a h集合的差C: c e代码实现⾸先这⾥交并差的实现是基于链表中的元素已经从⼩到⼤排完序的链表。

这⾥排序使⽤的是冒泡排序。

//链表的冒泡排序算法bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;while((L->next->next)!=tail){p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}//集合的并bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}elses->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//集合的交bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}p1=p1->next;}return true;}//集合的差bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL)s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//完整的代码实现#include<bits/stdc++.h>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;bool init(LinkList &L){L=(LinkList)malloc(sizeof(LNode));if(L==NULL)return false;L->next=NULL;return true;}bool search(LinkList &L, int x){LinkList p=L->next;while(p){if(p->data==x)return false;p=p->next;}return true;}bool creat_list(LinkList &L, char a[], int n) //采⽤尾插法建⽴单链表{LinkList p=L, s;for(int i=0; i<n; i++){if(search(L, a[i])==false)continue;s=(LinkList)malloc(sizeof(LNode));if(s==NULL)return false;s->data=a[i];s->next=NULL;p->next=s;p=s;}return true;}bool display(LinkList &L){LinkList p=L->next;if(p==NULL)return false;while(p){printf("%c ", p->data);p=p->next;}printf("\n");return true;}bool clear(LinkList &L){LinkList p;while(L){p=L->next;free(L);L=p;}L=NULL;return true;}bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}else{s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}return true;}bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}/*产⽣n个[min, max]的随机数。

⽤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中的元素。

集合的交集与并集运算集合是数学中的一种基本概念，用于表示一组具有共同特征的对象的结合体。

在集合的运算中，交集与并集是两个重要的操作。

本文将围绕集合的交集与并集运算展开讨论。

1. 交集运算交集运算是指将多个集合中共同拥有的元素提取出来形成一个新的集合。

记作A∩B，表示集合A与集合B的交集。

例如，设有集合A={1,2,3,4}，集合B={3,4,5,6}，则A∩B={3,4}。

这意味着集合A与集合B中，只有元素3和元素4同时存在于两个集合中。

交集运算的特点：（1）交换律：A∩B = B∩A。

即，两个集合的交集不受集合的顺序影响。

（2）结合律：(A∩B)∩C = A∩(B∩C)。

即，多个集合的交集按任意顺序进行运算，结果不变。

（3）分配律：A∩(B∪C) = (A∩B)∪(A∩C)。

即，集合的交集与并集的运算可以相互分配。

2. 并集运算并集运算是指将多个集合中的所有元素合并到一个新的集合中。

记作A∪B，表示集合A与集合B的并集。

例如，设有集合A={1,2,3}，集合B={3,4,5}，则A∪B={1,2,3,4,5}。

这意味着集合A与集合B中的所有元素组成了一个新的集合。

并集运算的特点：（1）交换律：A∪B = B∪A。

即，两个集合的并集不受集合的顺序影响。

（2）结合律：(A∪B)∪C = A∪(B∪C)。

即，多个集合的并集按任意顺序进行运算，结果不变。

（3）分配律：A∪(B∩C) = (A∪B)∩(A∪C)。

即，集合的并集与交集的运算可以相互分配。

需要注意的是，交集与并集运算的结果仍然是一个集合，并且不重复计算元素。

例如，在集合A={1,2,3}，集合B={2,3,4}的交集运算中，元素2和元素3只会计算一次。

综上所述，交集与并集运算是集合运算中的两个重要操作。

它们在解决实际问题中具有广泛的应用，能够帮助我们准确描述集合中的共同元素或合并多个集合的元素。

在数学推理和逻辑推演中，交集与并集的概念也是不可或缺的。