集合的交并差运算

#include<stdio.h>#include<malloc.h>#include<stdlib.h>struct set{int coef;struct set *next;};void createlist_p(struct set *&p,int n){int i;struct set *L;p=(struct set *)malloc(sizeof(set));p->next=NULL;for(i=n;i>0;i--){L=(struct set *)malloc(sizeof(set));牰湩晴尨请输入该集合中第%d个整数元素:,n-i+1); scanf(%d,&L->coef);L->next=p->next;p->next=L;}}//生成新链表用于存放两集合中的元素void printlist_p(struct set *&p){struct set *L;int i;L=p->next;晩??瀠楲瑮?该表为空!\n);while(L!=NULL){printf(%d ,L->coef);L=L->next;i++;}printf(\);}//打印输入的两集合中的元素void Addset(struct set *&p,struct set *&q,struct set *&r) {struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;k=p->next;for(;k;){m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;}//把第一个集合中的元素放在新集合中k=q->next;m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;for(;k;){for(n=r->next;(k->coef!=n->coef)&&n->next;){n=n->next;}//与新集合中的元素比较if((k->coef!=n->coef)&&!(n->next)){m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;}k=k->next;}//对第二个集合中的元素进行分析}//求A∪Bvoid Subset(struct set *&p,struct set *&q,struct set *&r){ struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;n=q->next;for(;n;){m=p->next;for(;(m->coef!=n->coef)&&m->next;){m=m->next;}if(m->coef==n->coef) {k=(struct set *)malloc(sizeof(set));k->next=r->next;r->next=k;k->coef=m->coef;}n=n->next;}}//求A∩Bvoid Intset(struct set *&p,struct set *&q,struct set *&r){ struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;m=p->next;for(;m;){n=q->next;for(;(m->coef!=n->coef)&&n->next;){n=n->next;}if(!n->next&&(m->coef!=n->coef)) {k=(struct set *)malloc(sizeof(set));k->next=r->next;r->next=k;k->coef=m->coef;}m=m->next;}}//求A-Bvoid bangzhu(){printf(\\t\t\t***********************************); printf(\\t\t\t* 求集合的交并差*);printf(\\t\t\t*********************************\n);}void main(){struct set *p,*q,*r;int m,n,node;bangzhu();for(;;){do{牰湩晴尨请输入您要选择操作的代码:\n);printf(：求两集合的并A∪B\n);printf(：求两集合的交A∩B\n);printf(：求两集合的差A-B\n);printf(：退出该程序\n);scanf(%d,&node);} while(node<0||node>3);if(node==0) exit(1);printf(\\t\t/*请输入集合A中元素的个数：*/\n);scanf(%d,&m);createlist_p(p,m);printf(\\t\t/*请输入集合B中元素的个数：*/\n);scanf(%d,&n);createlist_p(q,n);牰湩晴尨集合A中元素为:);printlist_p(p);牰湩晴尨集合B中元素为:);printlist_p(q);while(node<0||node>3);switch(node){case 1: Addset( p,q,r);printf(A∪B:\n);printlist_p(r);break;case 2: Subset( p,q,r);printf(A∩B:\n);printlist_p(r);break;case 3: Intset(p,q,r); printf(A-B:\n);printlist_p(r);break;}printf(\);}}可以了楼上方法是正确的，学习!把分给楼上主要原因是C程序中使用了C语言不支持的引用所致，修改如下：//---------------------------------------------------------------------------#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct set{int coef;struct set *next;} set ;void createlist_p(struct set **p,int n){int i;struct set *L;*p=(struct set *)malloc(sizeof(set));(*p)->next=NULL;for(i=n;i>0;i--){L=(struct set *)malloc(sizeof(set));牰湩晴尨请输入该集合中第%d个整数元素:,n-i+1); scanf(%d,&L->coef);L->next=(*p)->next;(*p)->next=L;}}//生成新链表用于存放两集合中的元素void printlist_p(struct set **p){struct set *L;int i=0;L=(*p)->next;晩??瀠楲瑮?该表为空!\n);while(L!=NULL){printf(%d ,L->coef);L=L->next;i++;}printf(\);}// 打印输入的两集合中的元素void Addset(struct set **p,struct set **q,struct set **r) {struct set *k,*m,*n;*r=(struct set *)malloc(sizeof(set));(*r)->next=NULL;k=(*p)->next;for(;k;){m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;k=k->next;}//把第一个集合中的元素放在新集合中k=(*q)->next;m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;k=k->next;for(;k;){for(n=(*r)->next;(k->coef!=n->coef)&&n->next;){n=n->next;}//与新集合中的元素比较if((k->coef!=n->coef)&&!(n->next)){m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;}k=k->next;}//对第二个集合中的元素进行分析}//求A∪Bvoid Subset(struct set **p,struct set **q,struct set **r){ struct set *k,*m,*n;(*r)=(struct set *)malloc(sizeof(set));(*r)->next=NULL;n=(*q)->next;for(;n;){m=(*p)->next;for(;(m->coef!=n->coef)&&m->next;){m=m->next;}if(m->coef==n->coef) {k=(struct set *)malloc(sizeof(set));k->next=(*r)->next;(*r)->next=k;k->coef=m->coef;}n=n->next;}}//求A∩Bvoid Intset(struct set **p,struct set **q,struct set **r){ struct set *k,*m,*n;(*r)=(struct set *)malloc(sizeof(set));(*r)->next=NULL;m=(*p)->next;for(;m;){n=(*q)->next;for(;(m->coef!=n->coef)&&n->next;){n=n->next;}if(!n->next&&(m->coef!=n->coef)) {k=(struct set *)malloc(sizeof(set));k->next=(*r)->next;(*r)->next=k;k->coef=m->coef;}m=m->next;}}//求A-Bvoid bangzhu(void){printf(\\t\t\t***********************************);printf(\\t\t\t* 求集合的交并差*);printf(\\t\t\t*********************************\n);}void main(){struct set *p,*q,*r;int m,n,node;bangzhu();for(;;){do{牰湩晴尨请输入您要选择操作的代码:\n);printf(：求两集合的并A∪B\n);printf(：求两集合的交A∩B\n);printf(：求两集合的差A-B\n); printf(：退出该程序\n);scanf(%d,&node);}while(node<0||node>3);if(node==0) exit(1);printf(\\t\t/*请输入集合A中元素的个数：*/\n);scanf(%d,&m);createlist_p(&p,m);printf(\\t\t/*请输入集合B中元素的个数：*/\n);scanf(%d,&n);createlist_p(&q,n);牰湩晴尨集合A中元素为:);printlist_p(&p);printf( 集合B中元素为:);printlist_p(&q);//while(node<0||node>3);switch(node){case 1: Addset( &p,&q,&r);printf(A∪B:\n);printlist_p(&r);break; B:\n);printlist_p(&r);break; ∩case 2: Subset( &p,&q,&r);printf(A．case 3: Intset(&p,&q,&r); printf(A-B:\n);printlist_p(&r);break;}printf(\);}}//---------------------------------------------------------------------------。

集合运算交并差集合是数学中常见的一个概念，它是由一组无序的元素所组成的。

在集合理论中，常常需要进行集合的交、并、差等运算。

本文将详细介绍集合运算的概念和常见的操作方法。

一、交集运算交集是指给定两个或多个集合时，由两个或多个集合中共有的元素所组成的新的集合。

交集运算可以用符号"∩"来表示。

例如，有集合A={1, 2, 3, 4, 5}和集合B={4, 5, 6, 7, 8}，则A和B的交集为A∩B={4, 5}。

交集运算即将A和B中共有的元素4和5提取出来。

二、并集运算并集是指给定两个或多个集合时，由这些集合中所有元素所组成的新的集合。

并集运算可以用符号"∪"来表示。

例如，有集合C={1, 2, 3}和集合D={3, 4, 5}，则C和D的并集为C∪D={1, 2, 3, 4, 5}。

并集运算即将C和D中的所有元素合并到一个新的集合中。

三、差集运算差集是指给定两个集合A和B时，由属于A但不属于B的元素所组成的新的集合。

差集运算可以用符号"-"来表示。

例如，有集合E={1, 2, 3, 4, 5}和集合F={4, 5, 6, 7, 8}，则E和F的差集为E-F={1, 2, 3}。

差集运算即从E中去掉属于F的元素。

总结起来，集合运算交并差是在集合理论中常见的操作方法。

交集提取出两个或多个集合中共有的元素，而并集合并了所有集合中的元素，差集则从一个集合中去掉了与另一个集合相同的元素。

在实际应用中，集合运算经常用于数据分析、数据库查询等领域。

例如，在数据库查询中，可以使用交集运算找出两个表格中共有的数据，使用并集运算将两个表格中的数据合并，使用差集运算将两个表格中不同的数据分开。

需要注意的是，在进行集合运算时，要保证操作的对象是集合，即元素无重复且无序。

一般情况下，集合运算允许空集的存在，即不含任何元素的集合。

最后，集合运算交并差是集合理论中重要的概念，它们在数学和计算机科学中都有广泛的应用。

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

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 运行示意图：。

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

离散数学实验报告专业班级：姓名：学号：实验成绩：1．【实验题目】集合运算2．【实验目的】编程实现集合的交、并、差和补运算。

3．【实验内容】从键盘输入两个命题变元P和Q的真值，求它们的合取、析取、条件和双条件的真值。

4. 【实验要求】通过以下界面提示实现相应的集合运算**************************************************************** 请分别输入集合A与集合B的元素：请选择（1—5）要进行的集合运算：1.集合的交运算（A⋂B）2.集合的并运算（A⋃B）3.集合的差运算（A-B）4.集合的补运算（～A=E-A）5.继续/退出（y/n）****************************************************************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中的元素逐一与数组B中的元素进行比较，把不相同的元素添加到数组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。

集合的并、交和差运算题目：编制一个演示集合的并、交和差运算的程序班级：姓名：学号：完成日期：一、需求分析1.本演示程序中，集合的元素限制在小写字母‘a’-‘z’之间。

集合的大小不限制，集合的输入形式为一个以“回车符”为结束标志的字符串，串中字符顺序不限，且允许出现重复字符或非法字符，程序运用时自动过滤去，输出的运算结果中将不含重复字符和非法字符。

2.演示程序以用户和计算机对话的形式进行，即在计算机终端中显示提示信息之后，有用户自行选择下一步命令，相应输入数据和运算结果在其后显示。

3.程序的执行命令有：1）选择操作2）任意键清屏4.数据测试（1）Set1=”magazine”, Set2=’paper”,Set1∪Set2=”aegimnprz”,Set1∩Set2=”ae”,Set1-Set2=”gimnz”;(2) Set1=”012oper4a6tion89”,Set2=”error data”,Set1∪Set2=”adeinoprt”,Set1∩Set2=”aeort”, Set1-Set2=”inp”.二、概要设计为实现上述功能，需要顺序表这个抽象数据类型。

1.顺序表抽象数据类型定义ADT sqlist{数据对象：D={ai|a i∈Elemset,i=1,2,3,…n,n>=0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2, … n}基本操作：InitList(&l)操作结果：构造一个空的顺序表l。

ListLength(l)初始条件：顺序表l已存在。

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

ListInsert_Sq(&L, i, e)初始条件：顺序表l已存在。

操作结果：在l中第i个元素前面插入元素e。

CreatSqList(&l, a[],n)初始条件：顺序表l已存在。

操作结果：将数组a[n]每个元素赋给顺序表l。

GetElem(L, i, &e)初始条件：顺序表l已存在。

高一数学知识点大全：集合的几种运算法则 高一数学知识点大全：集合的几种运算法则并集：以属于A或属于B的元素为元素的集合称为A与B的并（集），记作A∪B（或B∪A ），读作“A并B”（或“B并A”），即A∪B={x|x∈A，或x∈B}交集：以属于A且属于B的元差集表示素为元素的集合称为A与B的交（集），记作A∩B（或B∩A），读作“A交B”（或“B交A”），即A∩B={x|x∈A，且x∈B}例如，全集U={1，2，3，4，5}A={1，3，5}B={1，2，5}。

那么因为A和B中都有1，5，所以A∩B={1，5}。

再来看看，他们两个中含有1，2，3，5这些个元素，不管多少，反正不是你有，就是我有。

那么说A∪B={1，2，3，5}。

图中的阴影部分就是A∩B。

有趣的是；例如在1到105中不是3，5，7的整倍数的数有多少个。

结果是3，5，7每项减集合1再相乘。

48个。

对称差集：设A，B为集合，A与B的对称差集A？B定义为：A？B=（A-B）∪（B-A）例如：A={a，b，c}，B={b，d}，则A？B={a，c，d}对称差运算的另一种定义是：A？B=（A∪B）-（A∩B）无限集：定义：集合里含有无限个元素的集合叫做无限集有限集：令N*是正整数的全体，且N_n={1，2，3，……，n}，如果存在一个正整数n，使得集合A与N_n一一对应，那么A叫做有限集合。

差：以属于A而不属于B的元素为元素的集合称为A与B 的差（集）。

记作：A\B={x│x∈A，x不属于B}。

注：空集包含于任何集合，但不能说“空集属于任何集合”。

补集：是从差集中引出的概念，指属于全集U不属于集合A的元素组成的集合称为集合A的补集，记作CuA，即CuA={x|x∈U，且x不属于A}空集也被认为是有限集合。

例如，全集U={1，2，3，4，5}而A={1，2，5}那么全集有而A中没有的3，4就是CuA，是A的补集。

CuA={3，4}。

在信息技术当中，常常把CuA写成~A。

集合难题讲解
集合难题是指一些涉及集合论的复杂问题，这些问题往往涉及到多个概念和技巧的运用，需要深入的思考和分析才能解决。

以下是一些常见的集合难题讲解：
1. 子集与超集问题：给定两个集合A和B，判断A是否是B的子集或超集。

如果是子集，则A中的所有元素也一定在B中，但B中的元素不一定在A 中；如果是超集，则A中的元素一定在B中，但B中的所有元素不一定在
A中。

这个问题的关键在于理解子集和超集的定义和性质，并能够正确地应用它们。

2. 集合的交、并、差运算问题：给定两个集合A和B，要求计算它们的交集、并集和差集。

交集是指同时属于A和B的元素组成的集合；并集是指属于
A或属于B（或两者都属于）的元素组成的集合；差集是指属于A但不属于B的元素组成的集合。

这个问题的关键在于理解交、并、差运算的定义和性质，并能够正确地应用它们。

3. 集合的等价关系问题：给定两个集合A和B，判断它们是否等价。

如果两个集合等价，则它们的元素完全相同，即A中的每个元素都属于B，且B中的每个元素都属于A。

这个问题的关键在于理解等价关系的定义和性质，并能够正确地应用它们。

4. 集合的基数问题：给定一个集合A，要求计算它的基数（即元素个数）。

这个问题的关键在于理解集合基数的定义和性质，并能够正确地应用它们。

5. 集合的证明问题：给定一个集合A和B，要求证明A中的所有元素都属
于B或者不属于B。

这个问题通常涉及到对集合的元素的性质进行深入分析，以及正确地应用集合的性质和定理。

以上是几个常见的集合难题讲解，对于这些问题的解决需要深入理解集合论的基本概念和性质，并且需要具备一定的逻辑思维和分析能力。

使⽤单链表来实现集合的交并差运算数据结构使⽤单链表来实现集合的交并差运算数据结构问题描述该算法的设计，要求运⾏结果如下所⽰：集合的运算如下:原集合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中的元素。

集合的并交差集运算的设计青岛理工大学C++面向对象课程设计报告院(系): 计算机工程学院专业: 计算机科学与技术学生姓名: 刘文泽班级计算133 学号: 201207091 题目: 集合的并、交、差集运算的设计,,,,,起迄日期: ,2015.6.29,2015.7.10设计地点: 计算机学院机房指导教师: 巩玉玺、林孟达完成日期: 2015 年7月 10 日目录一、需求分析1. 选做此课题或项的目的2. 程序所实现的功能3. 问题解决方案二、内容设计1. 根据所选题目，给出模块图2. 编写程序关键代码三、调试分析1. 实际完成的情况说明2. 程序的性能分析。

3. 上机过程中出现的问题及其解决方案4. 程序中可以改进的地方说明。

四、用户手册五、设计总结六、参考文献七、附录一、需求分析1.选做此课题或项的目的用c++实现集合的并、交、差集运算。

2.程序所实现的功能(1)用户能够输入两个集合元素;(2)能够额按成集合的交、并、差运算; (3)集合的元素类型可以为整数、字符串和小数。

(4)输入运算结果。

(5)使用链表来表示集合，完成集合的合并，求交集等。

3、问题解决方案根据系统功能需求，可以将问题解决分为以下步骤: (1)应用系统分析，建立该系统的功能模块框图以及界面的组织和设计;(2)分析系统中的各个实体及他们之间的关系; (3)根据问题描述，设计系统的类层次; (4)完成类层次中各个类的描述;(5)完成类中各个成员函数的定义;1二、内容设计1.根据所选题目，给出模块图通过对系统功能的分析，集合交并差系统功能如图所示:(一) 集合的交集运算:分析:首先输出集合1与集合2的元素，然后输出集合1与集合2中相同的元素。

流程图如图所示:(二) 集合的并集运算:分析:首先输出集合1与集合2的元素，然后输出集合1与集合2中的全部元素。

流程图如图所示:2(三)差集的运算首先输出集合1减去集合2的结果，然后输出集合2减去集合1中的结果。

集合的交并差补与代数的加减乘除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。

集合的概念与运算总结在数学中，集合是由一组特定对象组成的。

这些对象可以是数字、字母、词语、人物、事物等等。

集合的运算是指对集合进行交、并、差等操作的过程。

本文将对集合的概念及其运算进行总结。

一、集合的概念集合是数学中的基础概念之一，通常用大写字母表示，如A、B、C 等。

集合中的对象称为元素，用小写字母表示。

一个元素要么属于一个集合，要么不属于，不存在属于但不属于的情况。

表示元素属于某个集合的关系可以用符号∈表示，不属于则用∉表示。

例如，对于集合A={1,2,3}，元素1∈A，元素4∉A。

集合还有一些常用的特殊表示方法，如空集∅表示不包含任何元素的集合，全集U表示某一给定条件下所有可能元素的集合。

二、集合的基本运算1. 交集运算(∩)交集运算是指将两个集合中共同拥有的元素合并成一个新的集合。

用符号∩表示。

例如，对于集合A={1,2,3}和集合B={2,3,4}，它们的交集为A∩B={2,3}。

2. 并集运算 (∪)并集运算是指将两个集合中所有的元素合并成一个新的集合。

用符号∪表示。

例如，对于集合A={1,2,3}和集合B={2,3,4}，它们的并集为A∪B={1,2,3,4}。

3. 差集运算（\）差集运算是指从一个集合中去除另一个集合的所有元素。

用符号\表示。

例如，对于集合A={1,2,3}和集合B={2,3,4}，集合A减去集合B的差集为A\B={1}。

4. 补集运算补集运算是指对于给定的全集U，从全集中去除某个集合中的元素得到的集合。

用符号'表示。

例如，对于集合A={1,2,3}和全集U={1,2,3,4,5}，A的补集为A'={4,5}。

三、集合运算的性质集合运算具有以下几个基本性质：1. 交换律交换律指的是对于任意两个集合A和B，A∩B = B∩A，A∪B =B∪A。

2. 结合律结合律指的是对于任意三个集合A、B和C，(A∩B)∩C = A∩(B∩C)，(A∪B)∪C = A∪(B∪C)。

实验二集合运算及关系运算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的并集。