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

一、实验目的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();}}。

if(IsElement(s.pS[i]))
Rs.insert(s.pS[i]);
return Rs;
}
Set Set::difference(const Set &s)const
{
Set Rs;
for(int i=1;i<=n;i++)
if(!(s.IsElement(pS[i])))
Rs.insert(pS[i]);
cout<<((s1.IsSubset(s4))?"YES":"NO")<<endl;
cout<<"s1 Union s2=";
s1.Union(s2).ShowElement();
cout<<"s1 intersection s2=";
s1.intersection(s2).ShowElement();
}
bool Set::IsSubset(const Set &s)const
{
if(s.n>n)
return false;
for(int i=1;i<=s.n;i++)
if(!IsElement(s.pS[i]))
return false;
return true;
}
bool Set::IsEqual(const Set &s)const
Set s2;
s2.insert(1);s2.insert(3);s2.insert(5);s2.insert(6);
cout<<"s2=";
s2.ShowElement();

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

<数据结构>课程设计题目:（1.1）集合的并、交和差运算的算法班级:姓名:XXX学号:完成日期:问题描述：设计一个能演示集合的并、交和差运算的程序。

要求：演示程序以用户和计算机的对话方式执行。

1、需求分析（1）输入的形式：命令：集合；如：Create:A;delete:A;Create:B{1,2,3,4,5};Show:BShow*;Help;Operation:A=B;Operation:A=A+B;输入值得范围：数值类型：int；最多创建集合数：100；（2）输出的形式：Error:Not find…Result:OK!Result:A={1,2,3,4,5};注意：集合中的元素是安从小到大的顺序排的，并且集合中的元素唯一。

（3）程序所能达到的功能。

实现集合的创建，增删改查，以及集合间的并、交和差运算。

（4）测试数据。

输入：Create:A={12,1,2,3,4};Create:B={3,4,5,6};Operation:C=A+B;Operation:D=A-B;Operation:E=A*B;Show*:;Quit:;2、概要设计图3.1 主题布局3、详细设计（1）基本操作：创建列表：State CreateList(List L)；删除列表中的元素:State DeleteList(List L,int index);向列表添加元素：State Add(List L,TYPE e)；查找元素：State FindByIndex(List L,int index,_TYPE e)；（2）集合操作：排序：void Sortascending(List L)；去重：State uniq_List(li l0,List L)删除集合：去除索引indexx.l[i];创建集合：void Create(char* name,char* str);查找集合：int find(const char* str,char ch,int start)；（3）集合间的操作：集合合并：State Union_List(li a,li b,List c)；集合交集：State Intersection_List(li a,li b,List c)；集合差集：State Substract_List(li a,li b,List c)；（4）数据结构typedef struct{TYPE* l;//整型数组int length;//列表长度int max_len;//列表最大长度}li,*List,**_List;li list_arr[100];//集合数组li indexx;//列表索引char str_arr[100][20];//字符串数组4、调试分析（无）5、用户使用说明集合格式:A={1,2,3};('A'为集合名称,'{}'为集合,'1'为集合中的元素) help:; --帮助create:A={1,2,3}; --创建集合Adelete:A; --删除集合Ashow:A; --显示集合Ashow*:; --显示所有集合cls:; --清屏operation:A=B+{1,2,3}*B-{1,5,6} --集合运算(无优先规则，即顺序运算) '+'为集合的并'-'为集合的差'*'为集合的交6、测试结果输出：Result:Create OK!Result: Create OK!Result: Create OK!Result: OK!Result: Create OK!Result: OK!Result: Create OK!Result: OK!Result:A={1,2,3,4,12}Result:B={3,4,5,6}Result:C={1,2,3,4,5,6,12}Result:D={1,2,5,6,12}Result:E={3,4}Result:exit...--------------------------------Process exited with return value 0Press any key to continue . . .图6.1:测试结果7、附录（附全部代码）/////////////////////////////////////////////////////////////////////////////// //编译环境：DEV-C++//日期：2014/12/6//名称：集合运算/////////////////////////////////////////////////////////////////////////////////// #include<stdio.h>#include<malloc.h>#include<string.h>#include<windows.h>#define MAX_LEN 20#define ADD_LEN 10#define OK 1#define TRUE 1//#define ERROR -1#define FALSE 0typedef int TYPE;typedef int State;typedef int BOOL;typedef TYPE* _TYPE;typedef struct{TYPE* l;int length;int max_len;}li,*List,**_List;State CreateList(List L){L->l=(_TYPE)malloc(MAX_LEN*sizeof(TYPE));if(!L->l)return ERROR;L->length=0;L->max_len=MAX_LEN;return OK;}State Add(List L,TYPE e){if(L->length>=L->max_len){_TYPE L0;L0=(_TYPE)realloc(L->l,(MAX_LEN+ADD_LEN)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len+=ADD_LEN;}L->l[L->length]=e;++L->length;return OK;}State AddRange(List L,_TYPE e,int length){int i;if(length<0)return ERROR;_TYPE L0;L0=(_TYPE)realloc(L->l,(MAX_LEN+length)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len+=length;for(i=0;i<length;++i){if(e[i])L->l[L->length+i]=e[i];else return ERROR;}L->length+=length;return OK;}State FindByIndex(List L,int index,_TYPE e){if(index<0||index>=L->length)return ERROR;*e=L->l[index];return OK;}int FindByE(List L,TYPE e){int i;for(i=0;i<L->length;++i){if(e==L->l[i])return i;}return -1;}void swap(_TYPE a,_TYPE b){TYPE t=*a;*a=*b;*b=t;}void Sort(List L,int campare(TYPE,TYPE)){int i,j;for(i=0;i<L->length-1;++i){for(j=i+1;j<L->length;++j){if(campare(L->l[i],L->l[j])){swap(&L->l[i],&L->l[j]);}}}}int IsMax(TYPE a,TYPE b){return a>b;}int IsMin(TYPE a,TYPE b){return a<b;}void SortDescending(List L){Sort(L,IsMin);}void Sortascending(List L){Sort(L,IsMax);}State DeleteList(List L,int index){int i,j;_TYPE L0;if(index<0||index>=L->length)return ERROR;if(L->length>=MAX_LEN&&L->length-1>L->max_len-ADD_LEN){ L0=(_TYPE)realloc(L->l,(MAX_LEN-ADD_LEN)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len-=ADD_LEN;}for(i=L->length-2;i>=index;--i){L->l[i]=L->l[i+1];}--L->length;}State uniq_List(li l0,List L){int length=l0.max_len,i,j;BOOL k;L->l=(_TYPE)malloc(sizeof(TYPE)*length);if(!L->l)return ERROR;L->length=0;L->max_len=length;for(i=0;i<l0.length;++i){k=TRUE;for(j=i+1;j<l0.length;++j){if(l0.l[i]==l0.l[j]){k=FALSE;break;}}if(k){Add(L,l0.l[i]);}}return OK;}State Union_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}while(j){Add(c,*b0);b0++;j--;}return OK;}State Intersection_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){b0++;j--;}else if((*a0)==(*b0)){Add(c,*a0);b0++;a0++;i--;j--;}else{a0++;i--;}}return OK;}State Chu_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else if((*a0)==(*b0)){b0++;a0++;i--;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}while(j){Add(c,*b0);b0++;j--;}return OK;}State Substract_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else if((*a0)==(*b0)){b0++;a0++;i--;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}return OK;}/////////////////////////////////////////////////////////////////li list_arr[100];li indexx;char str_arr[100][20];///////////////////////////////////////////////////////////////void Printf(char* str,List L){int i;if(L->length<=0){if(strlen(str)>0){printf("%s={(None)}\n",str);}return;}printf("%s={",str);for(i=0;i<L->length-1;++i){printf("%d,",L->l[i]);}printf("%d}\n",L->l[L->length-1]);}int find(const char* str,char ch,int start){int i,length=strlen(str);for(i=start;i<length;++i){if(str[i]==ch)return i;}return -1;}void Str_cpy(const char* str,int start,int end,char *str0){ int i,length=strlen(str);if(start<0||start>=length||end<0||end>length||end<=start){ return;}for(i=start;i<end;i++){if(str[i]==' '){++start;}elsestr0[i-start]=str[i];}str0[i-start]='\0';}void Caps(char* str,BOOL Up){int length=strlen(str),i;if(Up){for(i=0;i<length;++i){if(str[i]>='a'&&str[i]<='z'){str[i]-=32;}}}else{for(i=0;i<length;++i){if(str[i]<='Z'&&str[i]>='A'){str[i]+=32;}}}}void Read(List L,char* str){li list;CreateList(&list);int i,num=0,length=strlen(str);if(length<=0)return;for(i=0;i<length;++i){if(str[i]==','){Add(&list,num);num=0;}else{num*=10;num+=(str[i]-'0');}}if(num>0){Add(&list,num);}Sortascending(&list);uniq_List(list,L);}void Create(char* name,char* str){li list;int length=strlen(str),i;if(findByName(name)>=0){printf("Error:%s have already exist!\n",name);return;}CreateList(&list);Read(&list,str);strcpy(str_arr[indexx.length],name);list_arr[indexx.length]=list;Add(&indexx,indexx.length);printf("Result:Create OK!\n");}int findByName(char* str){int i;for(i=0;i<indexx.length;++i){if(strcmp(str_arr[indexx.l[i]],str)==0){return i;}}return -1;}int findOperater(const char* str,int start){int i=0,length=strlen(str);for(i=start;i<length;++i){if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/')return i;}return -1;}li operate(char* str,int start,li li_f){int i,length,end,index;li li_l,li_r;char set[100];end=findOperater(str,start+1);if(start<0){uniq_List(li_f,&li_r);return li_r;}if(str[start+1]=='{'){Str_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),set);Read(&li_l,set);}else{if(end<0)end=find(str,';',0);for(i=start+1;i<end;i++){set[i-start-1]=str[i];}set[i-start-1]='\0';index=findByName(set);if(index<0){printf("Error:%s have not exist!",set);return li_r;}li_l=list_arr[index];}switch(str[start]){case '+':Union_List(li_f,li_l,&li_r); break;case '-':Substract_List(li_f,li_l,&li_r); break;case '*':Intersection_List(li_f,li_l,&li_r);break;case '/':Chu_List(li_f,li_l,&li_r);break;default:printf("Error:opareter error...\n");}if(end==find(str,';',0))end=-1;return operate(str,end,li_r);}void func(char* str){char command[20]={"\0"};char str0[100],name[20]={"\0"};int i,j,end,start=find(str,':',0);li li_f;Str_cpy(str,0,start,command);Caps(command,FALSE);if(strcmp(str,"show*;")==0)goto loop;else if(strcmp(str,"quit;")==0)goto loop2;else if(strcmp(str,"help;")==0)goto loop3;if(strcmp(command,"delete")==0){Str_cpy(str,start+1,find(str,';',start+1),name);start=findByName(name);if(start<0){printf("Error:Not find!\n");return;}DeleteList(&indexx,start);printf("Result:Delete OK!\n");}else if(strcmp(command,"create")==0){Str_cpy(str,start+1,find(str,'=',start+1),name);if(strlen(name)==0){Str_cpy(str,start+1,find(str,';',start+1),name);if(strlen(name)<=0)return;}elseStr_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),str0);Create(name,str0);}else if(strcmp(command,"operation")==0){end=find(str,'=',start+1);Str_cpy(str,start+1,end,name);if(strlen(name)==0){return;}i=findByName(name);if(i<0){Create(name,"");i=findByName(name);}CreateList(&li_f);if(str[end+1]=='{'){Str_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),name);Read(&li_f,name);end=findOperater(str,end+1);}else{name[0]='\0';start=end;end=findOperater(str,end+1);if(end<0)Str_cpy(str,start+1,strlen(str)-1,name);elseStr_cpy(str,start+1,end,name);start=findByName(name);if(start<0){printf("Error:'%s' have not exist!",name);return;}li_f=list_arr[start];}Str_cpy(str,end,strlen(str),str0);list_arr[i]=li_f;list_arr[i]=operate(str0,findOperater(str0,0),li_f);printf("Result:OK!\n");}else if(strcmp(command,"show")==0){Str_cpy(str,start+1,find(str,';',start+1),name);start=findByName(name);if(start<0){printf("Error:Not find %s!\n",name);return;}printf("Result:");Printf(str_arr[indexx.l[start]],&list_arr[indexx.l[start]]);}else if(strcmp(command,"show*")==0){loop: for(i=0;i<indexx.length;++i){printf("Result:");Printf(str_arr[indexx.l[i]],&list_arr[indexx.l[i]]);}}else if(strcmp(command,"quit")==0){loop2: printf("Result:exit...");exit(0);}else if(strcmp(command,"help")==0){loop3:printf("<==================================================>\ n\n");printf("集合格式:A={1,2,3};('A'为集合名称,'{}'为集合,'1'为集合中的元素)\n");printf("help:; --帮助\n");printf("create:A={1,2,3}; --创建集合A\n");printf("delete:A; --删除集合A\n");printf("show:A; --显示集合A\n");printf("show*:; --显示所有集合\n");printf("cls:; --清屏\n");printf("operation:A=B+{1,2,3}*B-{1,5,6} --集合运算(无优先规则，即顺序运算)\n\t'+'为集合的并\n\t'-'为集合的差\n\t'*'为集合的交\n\n");printf("<==================================================>\ n\n");}else{system(command);}}BOOL IsIlligle(const char* str){int i,length=strlen(str);BOOL k=TRUE;for(i=0;i<length;++i){if((str[i]>='0'&&str[i]<='9')||(str[i]>='A'&&str[1]<='Z')||(str[1]>='a'&&str[i]<='z') )continue;switch(str[i]){case ';':case ':':case '{':case '}':case '+':case '-':case '*':case '=':case ' ':case '/':continue;default:k=FALSE;}break;}return k;}int main(){char str[100],str1[100];CreateList(&indexx);printf("输入'help;'查询...\n");while(1){printf("List->");gets(str);Str_cpy(str,0,strlen(str),str1);if(IsIlligle(str1)){func(str1);}else{printf("Error:have illegal character!\n");}}return 0;}。

HUNAN UNIVERSITY 离散数学课程实验报告题目：集合运算学生姓名：学生学号：专业班级：完成日期：一．实验目的1.熟悉集合的交，并，差，对称差和直积等集合运算；2.使用c++语言工具解决集合的运算问题；二．实验内容编写程序实现集合的交，并，差，对称差和直积集合运算三．实验过程算法分析1.集合的交：使用两个字符串数组A和B存储两个集合，依次遍历两个数组，找到相同的元素，就输出该元素，直到两个数组都遍历完毕为止，输出的所有的元素就是这两个集合的交；2.集合的并：依次遍历这两个数组，在第二个数组中，若找到与第一个数组中的某个元素相同的元素时，在第二个数组中删除该元素，最后输出第一个数组和第二个数组的所有元素，得到的结果即集合的并；3.集合的差：遍历数组A和B，在数组A中，若找到与B中某一元素相同的元素，则在数组A中删除该元素，最后一次输出数组A即可；4.集合的对称差：定义一个新的字符串数组C，将A的值全部赋给C（C==A）.。

遍历数组A和B，若在A中找到与B中某一元素相同的元素，则在A中删除该元素；遍历C与B，若在B中找到与C中某一元素相同的元素，则删除B中的该元素，最后依次遍历输出数组A和B即可；5.集合的直积：从数组A的第一个元素开始，每输出A中的一个元素的同时，对应输出B中所有的元素，中间用<,>连接，直到A中所有元素都输出完毕。

最后得到的序列便是A和B的直积流程图实验数据和分析测试数据：请输入第一个集合：a b 1 4请输入第二个集合：b g 4两个集合的交为：b 4两个集合的并为：a b 1 4 g第一个集合-第二个集合为：a 1两个集合的对称差为：a 1 g两个集合的直积为:<a,b> <a,g> <a,4> <b,b> <b,g> <b,4><1,b> <1,g> <1,4> <4,b> <4,g> <4,4>按照实验的算法设计程序，实现集合的各种基本运算。

实验报告题目：编制一个演示集合的并、交、和差运算的程序一、问题描述：设计一个程序，要求实现集合的并、交、和差的运算二、需求分析1.本演示程序中，集合的元素限定为数字。

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

3.程序执行的命令包括：1）构造集合1；2）构造集合2；3）求并集；4)求交集；5）求差集；6）结束。

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

4．测试数据（1） A={1、2、3、4、9} B={2、3、5、7、8}A∪B={9、4、3、2、1、8、7、5} A∩B={3、2} A－B={9、4、1}三、概要设计为实现上述程序功能，应以有序链表表示集合。

为此，需要两个抽象数据类型：有序表和集合1.有序表的抽象数据类型定义为：ADT OrderedList{数据对象：D={ai|ai∈CharSet,i=1,2,…,n,n>=0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,ai-1<ai,i=2,…,n}基本操作：InitList(&L)操作结果：构造一个空的有序表L。

DestroyList(&L)初始条件：有序表L已存在操作结果：销毁有序表L。

CreateList（&L，n）操作结果：构造一个含有n个元素的链表L。

ListLength(L)初始条件：链表L已经存在。

操作结果：返回L中数据元素的个数。

GetElem(L,i,&e)初始条件：链表L已经存在。

操作结果：用e返回L中第i个元素的值。

Equal（c1，c2）初始条件：链表L已经存在且不为空。

操作结果：判断链表L中两元素是否相等，若相等则返回true，否则返回false。

LocateElem(L,e,equal)初始条件：链表L已经存在，Equal是数据元素的判定函数。

965．计算集合中元素的数目使用len()函数可以计算集合中元素的数目。

例如：>>> s={'a','b','c','d','e'}>>> len(s)55.5.2 判断集合间的关系可以利用符号<、<=、>、>=、==、!=来判断两个集合的包含或相等关系。

假定s和t是两个集合，则：若s < t为真，则s是t的真子集。

若s > t为真，则s真包含子集t。

若s <= t为真，则s是t的子集。

若s >= t为真，则s包含子集t。

若s == t为真，则s与t相同。

若s != t为真，则s与t不相同。

举例如下：>>> s={'a','b','c','d','e'}>>> t={'a','b'}>>> s < tFalse>>> s > tTrue>>> s >= tTrue>>> s == tFalse另外，方法issubset()和issuperset()也可以判断集合间的关系。

若s和t是两个集合，则： 若s.issubset(t)为真，则s是t的子集(与s <= t 等价)。

若s.issuperset(t)为真，则s包含t(与s>= t等价) 。

5.5.3 集合的交并差运算1．求两个集合的交集集合对象的方法intersection()或'&' 操作可以求两个集合的交集。

下面的示例代码求集合s和t的交集。

>>> s = {1,2,3}>>> t = {1,2,4}>>> print(s.intersection(t), s & t) #用两种方法求交集{1, 2} {1, 2}2．求两个集合的并集集合对象的方法union()或'|' 操作可以求两个集合的并集。

离散数学交并补运算、差运算、异或运算的实现--biaobiao88对集合的交并补运算、差运算及异或运算的代码，可输⼊字符与数字，内容简单，详情请看以下代码#include<iostream>using namespace std;int main(){//全集uchar u[] = {'a','b','c','d','e','f','g','h'};char a[] = {'a','b','c','g'};char b[] = {'d','e','f','g'};char c[] = {'a','c','f'};char d[] = {'f','h'};////--------------------以下内容可输⼊操作---------------------------// cout << "请分别输⼊全集U、集合A、集合B、集合C、集合D的个数：" ;// int uu,aa,bb,cc,dd;// cin >> uu >> aa >> bb >> cc >> dd;// char u[uu],a[aa],b[bb],c[cc],d[dd];// cout << "请输⼊集合U中" << uu << "个元素：";// cin >> u;// cout << "请输⼊集合A中" << aa << "个元素：";// cin >> a;// cout << "请输⼊集合B中" << bb << "个元素：";// cin >> b;// cout << "请输⼊集合C中" << cc << "个元素：";// cin >> c;// cout << "请输⼊集合D中" << dd << "个元素：";// cin >> d;////--------------------以上内容可输⼊操作---------------------------//交运算b交cint bn = sizeof(b);int cn = sizeof(c);cout << "B∩C：";for(int i = 0;i < bn;i++){for(int j = 0;j < cn;j++){if(b[i] == c[j]){cout << b[i] << "";}}}cout << endl;//并运算a并bint an = sizeof(a);cout << "A∪B：";for(int i = 0;i < an;i++)//并运算操作，先输出⼀个字符数组，再对另⼀个字符数组进⾏挑选cout << a[i] << "";for(int i = 0;i < bn;i++){int flag = 1;for(int j = 0;j < an;j++){if(b[i] == a[j])//两元素相同，则不需要该元素，因为之前已经输出过该元素了{flag = 0;}}if(flag == 1){cout << b[i] << "";}}cout << endl;//差运算g = b - dint dn = sizeof(d);cout << "B-D ：";//差运算解释：在集合B中除去集合D中含有的元素for(int i = 0;i < bn;i++)//两层循环对两个数组依次遍历，不符合差运算条件的即不输出跳过{int flag = 1;for(int j = 0;j < dn;j++){if(b[i] == d[j]){flag = 0;}if(flag == 1){cout << b[i] << "";}}// for(int i = 0;i < dn;i++)// {// int flag = 1;// for(int j = 0;j < bn;j++)// {// if(d[i] == b[j])// {// flag = 0;// }// }// if(flag == 1)// {// cout << d[i] << " ";// }// }cout << endl;//⾮运算h=⾮dint un = sizeof(u);cout << "﹁D ：";for(int i = 0;i < un;i++)//⾮运算对全集u进⾏操作{int flag = 1;for(int j = 0;j < dn;j++){if(u[i] == d[j]){flag = 0;}}if(flag == 1){cout << u[i] << "";}}cout << endl;//b异或c//异或运算的公式为 b异或c=（b-c）并上（c-b）//解决集合异或问题，将分为两步进⾏//b-c// cout << "B-C ：";cout << "B异或C：";int m = 0;char zuo[m];//定义集合b-集合c，将结果存储在字符数组zuo中for(int i = 0;i < bn;i++){int flag = 1;for(int j = 0;j < cn;j++){if(b[i] == c[j])//如果两个元素相同，则说明重复了，此if语句为了排出重复元素的{flag = 0;}}if(flag == 1){zuo[m++] = b[i];//将满⾜条件的元素记录并输出cout << b[i] << "";}}// for(int i = 0;i < m;i++)// cout << zuo[i] << " ";// cout << endl;//c-b// cout << "C-B ：";for(int i = 0;i < cn;i++)//计算出集合C-集合B，在过程中对满⾜条件的元素继续进⾏判断，看是否与集合B-集合C中的元素重复{int flag = 1;for(int j = 0;j < bn;j++){if(c[i] == b[j])//同上{flag = 0;}}if(flag == 1)//对已满⾜集合C-集合B的元素继续判断是否与zuo数组中的元素是否有相同的，以下步骤即为合并俩集合并且输出 {int flag1 = 1;for(int k = 0;k < m;k++)if(zuo[k] == c[i])flag1 = 0;}if(flag == 1)cout << c[i] << "";// you[n++] = c[i];// cout << c[i] << " ";}}// for(int i = 0;i < n;i++)// cout << you[i] << " ";return0;}静态运⾏结果：动态运⾏结果：此代码为实验的要求，我⽤了⼀整个晚上的时间去实现这个我理想的⽬的，勉勉强强算是完成了最重要的是在于对离散数学中，集合的交并补、差运算、异或运算的理解，重在理解与应⽤，才能抽象出模型代码有点乱，但是思路还是在那的，认真看应该能理解。

float G[];\\用于存放A的幂集
intk;
char x;
n=strlen(A);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
ifA[i]=B[j];
C[i]=A[i];
printf(“A与B的交为：%d”C[i]);
printf(“\n”);
if(A[i] =B[j])
D[i]=A[i];
else
{
D[i]=A[i];
D[i+1]=A[j];
}
printf(“A与B的并为：%d”D[i]);
printf(“\n”);
if (A[i]!=C[j])
printf(“A与B的差为：%d”E[i]);
printf(“\n”);
if(A[i]!=C[j])
F[i]=A[i];
if( (B[j]!=C[j])
F[i+1]=B[i];
printf(“A与B的对称差为：%d”F[i]);
printf(“\n”);
}
if(i>=n)
{
if(G[0])
cout<<G<<endl;
else
cout<<"XX" <<endl;//表示空集
}
else
{
x =A[i];
k =strlen(B);
B[k]=x;
GetPowerSet(i+1,A);
B[k] = 0;
GetPowerSet(i+1,A);
}
intmain()