离散数学 实验四 编程实现集合的交、并、差和补运算。

一、实验目的1. 理解集合的概念和性质。

2. 掌握集合的基本运算，包括并集、交集、差集和补集。

3. 通过实际操作，加深对集合运算的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 集合运算库：Python内置的set模块三、实验内容1. 集合的定义与创建2. 集合的基本运算：并集、交集、差集和补集3. 集合运算的实际应用四、实验步骤1. 集合的定义与创建（1）定义集合：集合是由若干个元素组成的无序、互不相同的集合。

（2）创建集合：使用花括号{}或set()函数创建集合。

```python# 使用花括号创建集合set1 = {1, 2, 3, 4, 5}# 使用set()函数创建集合set2 = set([1, 2, 3, 4, 5])```2. 集合的基本运算（1）并集（union）：两个集合中所有元素的集合。

```python# 计算set1和set2的并集union_set = set1.union(set2)print(union_set) # 输出：{1, 2, 3, 4, 5}```（2）交集（intersection）：两个集合中共有的元素组成的集合。

```python# 计算set1和set2的交集intersection_set = set1.intersection(set2)print(intersection_set) # 输出：{1, 2, 3, 4, 5}```（3）差集（difference）：一个集合中存在，另一个集合中不存在的元素组成的集合。

```python# 计算set1和set2的差集difference_set = set1.difference(set2)print(difference_set) # 输出：{5}```（4）补集（symmetric_difference）：两个集合中不同时存在的元素组成的集合。

实现整数集合的并、交、差运算问题：编写⼀个程序，实现⼀个整数集合的基本运算要求：输⼊整数集合{2,4,1,3,5}和{2,5,10}，输出前者的元素个数以及它们进⾏集合的并、交、差运算设计⼀个类IntSet,包括私有数据成员len（集合的长度）和数组s（存放集合元素），以及如下⽅法： public void insert(int d) 向集合中添加⼀个元素，重复的元素不能添加public int length() 返回集合的元素个数public int getInt(int i) 返回集合中位置i的元素public void disp() 输出集合的所有元素public IntSet union(IntSet s2) 实现两个集合的并运算public IntSet intersection(IntSet s2) 实现两个集合的交运算public IntSet difference(IntSet s2) 实现两个集合的差运算public IntSet copySet(IntSet s2) 实现两个集合的拷贝Java代码：public class IntSet {private int len; //集合长度private int[] s; //数组public IntSet() {len = 0;s = new int[100];}public void resize() //重置数组{int[] b = new int[2*s.length];System.arraycopy(s, 0, b, 0, s.length);s = b;}public void insert(int d) //集合中插⼊元素{if(len>=s.length){resize();}for(int i=0;i<len;i++) {if(s[i]==d){return;}}s[len]=d;len++;}public int length() //获取集合长度{return len;}public int getInt(int i) {if(i>=0 && i<len){return s[i];}else {return -1;}}public void disp() {for(int i=0;i<len;i++){System.out.print("\t"+s[i]);}}public IntSet union(IntSet s2) //并{int same;for(int i=0;i<this.len;i++){same = 0;for(int j=0;j<s2.len;j++){if(this.getInt(i)==s2.getInt(j)){same = 1;break;}if(same == 0){this.insert(s2.getInt(j));}}}return this;}public IntSet intersection(IntSet s2) { //交int same;for(int i=0;i<this.len;i++) {same = 0;for(int j=0;j<s2.len;j++) {if(this.s[i] == s2.getInt(j)){same = 1; //找到重复的元素，则same=1 break;}}if(same == 0) {//找到不重复的元素，则删除 for(int k=i;k<this.len;k++){this.s[k] =this.s[k+1];}i--;this.len--;}}return this;}public IntSet difference(IntSet s2) { //差int same;for(int i=0;i<this.len;i++) {same = 0;for(int j=0;j<s2.len;j++) {if(this.s[i] == s2.getInt(j)){same = 1; //找到重复的元素，则same=1 break;}}if(same == 1) {//找到重复的元素，则删除for(int k=i;k<this.len;k++){this.s[k] =this.s[k+1];}i--;this.len--;}}return this;}public IntSet copySet(IntSet s2) {this.len = s2.len;for(int i=0;i<s2.len;i++) {this.s[i] = s2.getInt(i);}return this;}}测试代码：public class Test {public static void main(String[] args) { IntSet s1,s2;s1 = new IntSet();s2 = new IntSet();s1.insert(2);s1.insert(4);s1.insert(1);s1.insert(3);s1.insert(5);s1.disp();s2.insert(2);s2.insert(5);s2.insert(10);System.out.println();s2.disp();// s1.union(s2);// System.out.println();// s1.disp();// s1.intersection(s2);// System.out.println();// s1.disp();// s1.difference(s2);// System.out.println();// s1.disp();// IntSet s6 = new IntSet();// s6.copySet(s2);// s6.disp();s2.difference(s1);System.out.println();s2.disp();}}。

C语言是一种广泛应用的计算机程序设计语言，它具有高效、灵活、可移植等特点，因此在计算机科学领域被广泛应用。

本篇文章将探讨在C语言中如何求集合的并集、交集和差集运算。

一、集合的概念集合是数学中重要的概念，它是由元素组成的无序的集合体。

在计算机科学中，我们常常需要对集合进行各种操作，比如求并集、交集、差集等。

二、集合的表示方法在C语言中，我们可以使用数组来表示集合。

数组是一种非常基础的数据结构，它由相同类型的元素组成的有序集合。

我们可以通过定义数组来表示一个集合，并通过遍历数组来进行各种集合运算。

三、集合的并集运算集合A和集合B的并集运算是指将A和B中的所有元素放在一起组成一个新的集合。

在C语言中，我们可以通过遍历两个数组，将它们的元素放在一个新的数组中即可实现并集运算。

下面是C语言中求两个集合的并集运算的示例代码：```#include <stdio.h>int m本人n() {int setA[] = {1, 2, 3, 4, 5};int setB[] = {3, 4, 5, 6, 7};int setSize = 5;int setUnion[10];int unionSize = 0;for (int i = 0; i < setSize; i++) {setUnion[unionSize++] = setA[i]; }for (int i = 0; i < setSize; i++) {int found = 0;for (int j = 0; j < setSize; j++) {if (setB[i] == setA[j]) {found = 1;break;}}if (!found) {setUnion[unionSize++] = setB[i];}}// 输出并集for (int i = 0; i < unionSize; i++) {printf("d ", setUnion[i]);}return 0;}```以上代码中，我们定义了两个集合setA和setB，分别表示集合A和集合B，然后通过遍历这两个数组，将它们的元素放入一个新的数组setUnion中。

【实验目的】通过编程实现求给定集合A和B的并集C（C=A∪B）的运算。

【实验内容】已知所给集合A和B，求A与B 的并集C（C=A∪B）。

【实验原理】因为并集的定义为：C={x|x∈A∨x∈B}，所以，只要将集合A与B合在一起就得到了并集C。

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

【程序代码】#include<stdio.h>int main(){int a[101],b[101],c[201]={0};int m,n;scanf("%d%d",&m,&n);for(int i=1;i<=m;i++)scanf("%d",&a[i]);for(int i=1;i<=n;i++)scanf("%d",&b[i]);for(int i=1;i<=m;i++)c[i]=a[i];int i=m+1;int k;for(int j=1;j<=n;j++){int t=1;for(k=1;k<=m;k++){if(a[k]==b[j])t=0;}if(t==1){c[i]=b[j];i++;}}for(int i=1;i<=m+n;i++){if(c[i]!=0)printf("%d ",c[i]);}}【实验结果】【实验心得】首先想到的是数组，先将数组a[],赋值给c[],然后通过两层for循环来判断b[],是否与a[]重复，如若不重复，将b[]赋值给c[]。

在开始的时候由于for循环套错位置出错，后设置一flag来判断b[]和a[]是否有重复的元素。

数据结构1.课程设计题目：集合的运算：交、并、补（难度系数：1.2）全集：大写字母‘A’~’Z’要求实现以下功能：1、集合的输入：自动去掉重复和非法的字符2、集合的显示：输出集合的全部元素3、输出一个给定集合的补集4、输出两个给定集合的交集和并集输入、输出方法自行设计，要易于操作、不易死机。

2.课程设计目的及要求：检验理论课学习的效果以及综合运用的能力。

训练学生进行复杂程序设计的技能和培养良好程序设计的习惯。

本课程设计的任务是要求学生使用C++语言编程，运用理论课所要求掌握的面向对象的类、模板、继承、重载等，结合上学期“数据结构”课程内容，实现线性表的系列操作。

3.题目需求分析及概要设计：根据课程设计题目的要求，程序中要实现集合的输入、集合的显示、输出一个给定集合的补集以及输出两个给定集合的交集和并集。

因此，在程序界面方面，设计了一个菜单,设计4个菜单栏,方便用户通过选择菜单去实现相应的功能及退出程序。

针对程序中要实现的功能，建立了头文件jihe.h主函数：void main()结构函数：typedef struct实现功能的函数有：输入集合：void Input(Gather &g,const Gather &corpora)输出集合：void Output(const Gather &g)输出补集：void OutputO(const Gather &g)输出并集：void OutputU(Gather g1,Gather g2,const Gather &corpora)输出交集：void OutputI(const Gather &g1,const Gather &g2)菜单：void Menu()4.详细设计：数据结构（类的定义、解释、实现、方法）1）：void main()：实现引用菜单2）void Menu()：用于实现菜单功能的选择，用switch…case…选择需要实现的功能：3）void Input(Gather &g,const Gather &corpora)：这个函数的主要功能是运用字符串与数组实现集合的输入，形参中g用来保存所输入的集合，其基本设计思路:用string content2="ABCDEFGHIJKLMNOPQRSTUVWXYZ";表示全集；首先通过一次循环去除非法字符串，通过一次循环条件去除重复字符串，然后再次通过循环再次去除非法字符串。

【问题描述】编制一个能演示执行集合的并、交和差运算的程序【基本要求】（1）集合的元素限定为小写字母字符[ 'a'......'z' ]（2 ）演示程序以用户和计算机对话的方式执行【测试数据】【实现提示】以有序链表表示集合【代码过程】1。

先定义集合的数据类型notes.htypedef struct LNode...{ElemType data;LNode *next;}*Link, *Position;typedef struct...{Link head,tail;int len;}LinkSet;//~#include<stdio.h>#include <malloc.h>#include <stdlib.h>//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define ElemType int //存放数据的类型typedef int Status; //函数的返回值//~/**//****************** 函数定义*********************/ Status InitSets(LinkSet &ls)...{//初始化集合ls.head = (Link) malloc( sizeof(Link));ls.tail = (Link) malloc( sizeof(Link));if(!ls.head || !ls.tail) exit(OVERFLOW); //如果分配失败>next = ls.tail->next = NULL; //头、尾指针为空ls.len = 0; //长度为0return OK;}Status CreateNode(Link &link,ElemType e)...{//创建一节点，内容为elink = (Link) malloc( sizeof(Link));if(!link) exit(OVERFLOW);link->data = e; //值设定link->next = NULL; //指向空return OK;}Position PriorInsertNode(LinkSet &ls,Link &link)...{//找出节点link要插入到ls的前一个节点if(!ls.head->next) return ls.head;Link h1 = ls.head->next, h2 = h1->next; //h1：前一节点，h2:前一节点的后一节点if(link->data < h1->data) return ls.head; //如果比第一个节点小，返回头指针while(h1 && h2)...{if(h1->data < (link->data) && h2->data > (link->data) ) //如果>h1 && <h2，说明找到插入的地方了break;if(h1->data == (link->data) || h2->data ==(link->data) )return NULL; //如果重复，返回NULL else //否则，顺次往后挪一个节点h1=h2,h2=h1->next;}return h1;}Status Append(LinkSet &ls, Link &link)...{//向集合末尾追加节点if(ls.head->next == NULL) ls.head->next = link;else ls.tail->next->next = link;ls.tail->next = link;ls.len ++;return OK;}Status InsertNode(LinkSet &ls, Link &link)...{//向集合中插入节点Position p = PriorInsertNode(ls,link);if(!p) return ERROR; //如果集合中已有相应元素link->next = p->next;if(!p->next) ls.tail->next = link; //如果前一节点为尾节点，修改tail p->next = link;ls.len++;return OK;}Position PriorNode(LinkSet &ls, Link &link)...{//返回集合中该节点的前一节点,不存在返回NULLint j=0;Link pre,h = ls.head;while(h->next && j<=ls.len && h!=link)...{pre = h; h=h->next; j++;}if(j==0) return NULL;return pre;}Status PrintSets(LinkSet &ls)...{//打印集合Link h=ls.head->next;printf("[ ");while(h)...{printf("%c ",h->data);h = h->next;}printf(" ] ");return OK;}Position GetHead(LinkSet &ls)...{//获得集合的头节点return ls.head;}Position NextPos(Link &link)...{//获得当前节点的下一个节点return link?link->next:link;}Status Empty(LinkSet &ls)...{//空为真return ls.head->next==NULL;}ElemType GetCurElem(Link &link)...{//获得当前节点的数据return link->data;}int Compare(Link &la, Link &lb)...{//判断两个节点的大小return la->data - lb->data;}int Compare(ElemType e1, ElemType e2)...{//比较两个数字的大小return e1-e2;}Status DelFirst(LinkSet &ls,Link &q)...{//已知h为线性链表的头节点,删除表中的第一个节点,并以q返回Link h = ls.head;if(!h->next) return ERROR;q = h->next;h->next = h->next->next;q->next=NULL;ls.len--;return OK;}Status FreeNode(Link &l)...{//释放节点,有问题free(l);return OK;}Status UnionSets(LinkSet lsa, LinkSet &lsb, LinkSet &lsc)...{ //已知集合ls1,ls2的元素按值非递减排列//将集合ls1，ls2的并集到ls3if( !InitSets(lsc) ) return ERROR;Link node;Link ha = lsa.head, hb=lsb.head; //找到两节点的头指针Link pa = NextPos(ha), pb = NextPos(hb);while( !Empty(lsa) && !Empty(lsb) )...{int result = Compare(pa,pb); //比较两节点大小if( result<0) ...{DelFirst(lsa,node);Append(lsc,node); pa = NextPos(ha); //向lsc插入lsa 的相关节点}else if(result>0)...{ //向lsc 插入lsb的相关节点DelFirst(lsb,node);Append(lsc,node); pb = NextPos(hb);}else...{DelFirst(lsb,node); pb = NextPos(hb);//如果两节点相同，删除lsb中重复的节点，即以lsa为标准}}while(!Empty(lsa))...{DelFirst(lsa,node);Append(lsc,node);}while(!Empty(lsb))...{DelFirst(lsb,node);Append(lsc,node);}return OK;}Status IntersectionSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{//已知集合ls1,ls2的元素按值非递减排列//将集合ls1，ls2的交集到ls3if( !InitSets(lsc) ) return ERROR;Link node;Link ha = lsa.head, hb=lsb.head;Link pa = NextPos(ha), pb = NextPos(hb);while( !Empty(lsa) && !Empty(lsb) )...{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...{DelFirst(lsb,node); Append(lsc,node);pb = NextPos(hb);DelFirst(lsa,node);pa = NextPos(ha);}}while(!Empty(lsa))...{DelFirst(lsa,node);Append(lsc,node);}return OK;}Status DifferenceSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{ //已知集合ls1,ls2的元素按值非递减排列//ls3 = ls1 - ls2if( !InitSets(lsc) ) return ERROR;Link node;Link ha = lsa.head, hb=lsb.head;Link pa = NextPos(ha), pb = NextPos(hb);//,pb2 = NextPos(pb1);while( !Empty(lsa) && !Empty(lsb) )...{int result = Compare(pa,pb);if( result<0) ...{DelFirst(lsa,node);Append(lsc,node);pa = NextPos(ha);}else if(result>0)...{DelFirst(lsb,node); pb = NextPos(hb);}else...{DelFirst(lsa,node); pa = NextPos(ha);DelFirst(lsb,node); pb = NextPos(hb);}}return OK;}Status CopySets(LinkSet lsa, LinkSet lsb)...{//将集合lsa拷贝到lsb中InitSets(lsb);Link la = lsa.head->next, lb = lsb.head->next;while(la)...{Link node;CreateNode(node,la->data);lb=node;lsb.len++;la = la->next;lb = lb->next;}lsb.tail = lb;return OK;}#include "constValues.h" //常量头文件#include "notes.h" //节点定义头文件#include "setsFun.h" //集合操作函数头文件/**//**************** 测试***********************************/void Initialization()...{printf("************************************************************************* *** " );printf("*MakeSet1-1 MakeSet1-2 Union-u Intersection-i Difference-d Quit-q * " );printf("************************************************************************* *** " );}void main()...{LinkSet set1,set2,set3,seta,setb;InitSets(set1),InitSets(set2); //初始化集合while(1)...{Initialization();printf("集合Set1:");PrintSets(set1); //打印集合set1printf("集合Set2:");PrintSets(set2); //打印集合set1printf("请键入操作代码:");fflush(stdin); //清空缓冲区char oper = getchar();char setsContent[200];switch(oper)...{case '1': //集合set1 赋值printf("请输入集合Set1的内容：");fflush(stdin);gets(setsContent);InitSets(set1);SetSets(set1,setsContent);break;case '2': //集合set1 赋值printf("请输入集合Set1的内容：");fflush(stdin);gets(setsContent);InitSets(set2);SetSets(set2,setsContent);break;case 'u':case 'U': //求并InitSets(set3);CopySets(set1,seta); //因为求并的算法是添加一个节点，删除set1,set2中对应的节点，CopySets(set2,setb); //所以要复制一份UnionSets(seta,setb,set3); //下同printf("set1 U set2=: ");PrintSets(set3);fflush(stdin);getchar();break;case 'i':case 'I': //求交InitSets(set3);CopySets(set1,seta);CopySets(set2,setb);IntersectionSets(seta,setb,set3);printf("set1 交set2=: ");PrintSets(set3);fflush(stdin);getchar();break;case 'd':case 'D': //求差InitSets(set3);CopySets(set1,seta);CopySets(set2,setb);DifferenceSets(seta,setb,set3);printf("set1 - set2=: ");PrintSets(set3);fflush(stdin);getchar();break;case 'q':case 'Q':exit(0);break;}system("cls"); //清屏} }//~。

大连民族学院计算机科学与工程学院实验报告实验题目：集合的运算课程名称：离散数学实验类型：□演示性□验证性□操作性□设计性□综合性专业：网络工程班级：网络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中元素存储完毕。

离散数学实验报告专业班级：12级计算机本部一班姓名：鲍佳珍学号：201212201401016 实验成绩：1．【实验题目】命题逻辑实验四2．【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。

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

4、【实验要求】C或C＋＋语言编程实现5.【算法描述】（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的子集。

以下每一个运算都要求先将集合C置成空集。

（2）二个集合的交运算：A⋂B={x|x∈A且x∈B}把数组A中元素逐一与数组B中的元素进行比较，将相同的元素放在数组C 中，数组C便是集合A和集合B的交。

C语言算法：for(i=0;i<m;i++)for(j=0;j<n;j++)if(a[i]= =b[j]) c[k++]=a[i];（3）二个集合的并运算：A⋃B={x|x∈A或x∈B}把数组A中各个元素先保存在数组C中。

将数组B中的元素逐一与数组A中的元素进行比较，把不相同的元素添加到数组C中，数组C便是集合A和集合B 的并。

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={x|x∈A且x∉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++; } }（5）集合的补运算：～A=B-A={x|x∈B且x∉A}将数组E中的元素逐一与数组A中的元素进行比较，把不相同的元素保存到数组C中，数组C便是集合A关于集合E的补集。

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