编制一个能演示执行集合的交、并和差运算的程序

合集下载

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

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

C语言实现集合的交,并,差公司内部编号:(GOOD-TMMT-MMUT-UUPTY-UUYY-DTTI-【问题描述】编制一个能演示执行集合的并、交和差运算的程序【基本要求】(1)集合的元素限定为小写字母字符[ 'a'......'z' ](2 )演示程序以用户和计算机对话的方式执行【测试数据】【实现提示】以有序链表表示集合【代码过程】1。

先定义集合的数据类型.{ElemType data;LNode *next;}*Link, *Position;typedef struct...{Link head,tail;int len;}LinkSet;.{.{.{if(h1->data < (link->data) && h2->data > (link->data) ) .{ .{.{.{pre = h; h=h->next; j++;}if(j==0) return NULL;return pre;}Status PrintSets(LinkSet &ls)...{.{printf("%c ",h->data);h = h->next;}printf(" ] ");return OK;}Position GetHead(LinkSet &ls)...{.{.{.{.{.{.{.{.{int result = Compare(pa,pb); .{DelFirst(lsa,node);Append(lsc,node); pa =NextPos(ha); .{ .{DelFirst(lsb,node); pb = NextPos(hb);.{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)...{ .{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)...{.{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)...{.{Link node;CreateNode(node,la->data);lb=node;++;la = la->next;lb = lb->next;}= lb;return OK;}.{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); .{Initialization();printf("集合Set1:");PrintSets(set1); .{case '1': //集合set1 赋值printf("请输入集合Set1的内容:");fflush(stdin);gets(setsContent);InitSets(set1);SetSets(set1,setsContent);break;case '2': //集合set1 赋值printf("请输入集合Set1的内容:");fflush(stdin);gets(setsContent);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=: ");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"); //清屏}} //~。

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

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

实验报告实验课程:数据结构实验项目:实验一集合的并交差运算专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(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个元素赋值给elem if(!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个元素赋值给elemif(!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;}。

集合的并交差运算c++

集合的并交差运算c++

集合的并交差运算c++在C++中,集合的并、交、差运算是常见的操作。

集合是一种数据结构,它可以存储一组不同的元素,这些元素没有重复。

以下是集合的并、交、差运算的示例代码:1. 集合的并运算set<int> setA;set<int> setB;set<int> setUnion;set_union(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(setUnion, setUnion.begin()));2. 集合的交运算set<int> setA;set<int> setB;set<int> setIntersection;set_intersection(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(setIntersection,setIntersection.begin()));3. 集合的差运算set<int> setA;set<int> setB;set<int> setDifference;set_difference(setA.begin(), setA.end(), setB.begin(),setB.end(), inserter(setDifference, setDifference.begin()));以上代码使用STL库中的set容器和相应的算法函数实现集合的并、交、差运算。

其中,set_union()函数可以将两个集合的并集放入一个新的集合中,set_intersection()函数可以将两个集合的交集放入一个新的集合中,set_difference()函数可以将两个集合的差集放入一个新的集合中。

使用inserter()函数可以将新集合的元素插入到新集合的任意位置。

数据结构课程设计_集合的并、交和差运算

数据结构课程设计_集合的并、交和差运算

数据结构课程设计学院:信息科学与工程学院专业:计算机科学与技术班级:学号:学生姓名:指导教师:2009 年12 月25 日一、实验内容实验题目:编制一个演示集合的并、交和差运算的程序。

需求分析:1、本演示程序中,集合的元素限定为小写字母字符[“a”…”z”]。

集合输入的形式为一个以“回车符“为结束标志的字符串,串中字符顺序不限。

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

3、程序执行的命令包括:1)构造集合1;2)构造在集合2;3)求并集;4)求交集;5)求差集;6)返回;7)结束。

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

二、数据结构设计为了实现上述程序的功能,应以有序链表表示集合。

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

1、有序表的抽象数据类型定义为:readdata(pointer head)初始条件:head是以head为头节点的空链表。

操作结果:生成以head为头节点的非空链表。

pop(pointer head)初始条件:head是以head为头节点的非空链表。

操作结果:将以head为头节点的链表中数据逐个输出。

2、集合的抽象数据类型定义为:and(pointer head1,pointer head2,pointer head3)初始条件:链表head1、head2、head3已存在操作结果:生成一个由head1和head2的并集构成的集合head3。

or(pointer head1,pointer head2,pointer head3)初始条件:链表head1、head2、head3已存在操作结果:生成一个由head1和head2的交集构成的集合head3。

differ(pointer head1,pointer head2,pointer head3)初始条件:链表head1、head2、head3已存在操作结果:生成一个由head1和head2的差集构成的集合head3。

集合的并交差运算

集合的并交差运算

石河子大学《集合的并,交和差运算》程序设计基础课程设计报告二OO八年六月二十五日目录一.编程目的: (2)二.设计要求: (2)三.各函数功能说明: (2)四.流程图: (22)五.总结: (7)参考书目 (24)一.编程目的:编写数学程序,能够演示执行集合的集合的并,交和差运算的程序,可以任意对两个集合进行集合之间的运算。

通过该程序的编写,更加熟练的掌握类和动态链表。

经过自己的查找和询问,让自己对书上的知识理解的更加透彻一点了,该程序让我们把书上的知识灵活运用,让我们把书上的知识变活了。

二.设计要求:1.集合的限定:集合元素必须为小写字母2.在屏幕上输出全部运算情况三.各函数功能说明:函数源代码以及函数的功能:#include<iostream>using namespace std;typedef struct pointer{char dat;struct pointer *link;} pointer;void readdata(pointer *head){ //读集合pointer *p;char tmp;cin>>tmp;while(tmp!='0'){if((tmp<'a')||(tmp>'z')){cout<<"\n";return;}p=new pointer;p->dat=tmp;p->link=head->link;head->link=p;cin>>tmp;//cout<<tmp<<" ";}}void disp(pointer *head){ //显示集合数据pointer *p;p=head->link;while(p!=NULL){cout<<p->dat<<" ";p=p->link;}cout<<endl;}void bing(pointer *head1,pointer *head2, pointer *head3){ //计算集合1与集合2的并pointer *p1,*p2,*p3;p1=head1->link;while(p1!=NULL){p3->dat=p1->dat;p3->link=head3->link;head3->link=p3;p1=p1->link;}p2=head2->link;while(p2!=NULL){p1=head1->link;while((p1!=NULL)&&(p1->dat!=p2->dat))p1=p1->link;if(p1==NULL){p3=(pointer *)malloc(sizeof(struct pointer));p3->dat=p2->dat;p3->link=head3->link;head3->link=p3;}p2=p2->link;}}void jiao(pointer *head1,pointer *head2, pointer *head3){ //计算集合1与集合2的交pointer *p1,*p2,*p3;p1=head1->link;while(p1!=NULL){p2=head2->link;while((p2!=NULL)&&(p2->dat!=p1->dat))if((p2!=NULL)&&(p2->dat=p1->dat)){p3=new pointer;p3->dat=p1->dat;p3->link=head3->link;head3->link=p3;}p1=p1->link;}}void cha(pointer *head1,pointer *head2, pointer *head3){ //计算集合1与集合2的差pointer *p1,*p2,*p3;p1=head1->link;while(p1!=NULL){p2=head2->link;while((p2!=NULL)&&(p2->dat!=p1->dat))p2=p2->link;if(p2==NULL){p3=new pointer;p3->dat=p1->dat;p3->link=head3->link;head3->link=p3;}p1=p1->link;}}main(){pointer *head1,*head2,*head3;head1=new pointer;head1->link=NULL;head2=new pointer;head2->link=NULL;head3=new pointer;head3->link=NULL;cout<<"输入集合1:"<<endl;readdata(head1);cout<<"输入集合2:"<<endl;readdata(head2);/*cout<<"集合1为:"<<endl;disp(head1);cout<<"集合2为:"<<endl;disp(head2); */cout<<"集合1与集合2的并为:"<<endl;bing(head1,head2,head3);disp(head3);head3->link=NULL;cout<<"集合1与集合2的交为:"<<endl;jiao(head1,head2,head3);disp(head3);head3->link=NULL;cout<<"集合1与集合2的差为:"<<endl;cha(head1,head2,head3);disp(head3);}运行结果:四.函数框架图:五.总结:在做程序设计前就已经感觉到我设计的《集合的并,交和差运算》比较复杂,不仅要写出实现各种功能的函数还要保证函数之间的连接,怎样通过函数之间的关系能很好的把函数连接起来,还要保证程序能够很好的而且有效的运行。

顺序表实验

顺序表实验

《数据结构》实验报告题目:_顺序表的实现学号:______姓名:___张磊_______ 东南大学成贤学院计算机系实验题目一、实验目的1.掌握顺序表的基本操作,实现顺序表的插入、删除、查找等基本运算。

二、实验内容1.完善顺序表的定义,并运用其实现线性表的操作。

2.(课上任务)选题一:集合的交、并、差运算【问题描述】编制一个能演示执行集合的交、并和差运算的程序。

【任务要求】1)集合元素用小写英文字母,执行各种操作应以对话方式执行。

2)算法要点:利用顺序表表示集合;理解好三种运算的含义【测试数据】自行设定,注意边界等特殊情况。

选题二:文章编辑功能:输入一页文字,程序可以统计出文字、数字、空格的个数。

静态存储一页文章,每行最多不超过80个字符,共N行;要求①分别统计出其中英文字母数和空格数及整篇文章总字数;②统计某一字符串在文章中出现的次数,并输出该次数;③删除某一子串,并将后面的字符前移。

存储结构使用顺序表,分别用几个子函数实现相应的功能;输入数据的形式和范围:可以输入大写、小写的英文字母、任何数字及标点符号。

输出形式:①分行输出用户输入的各行字符;②分4行输出"全部字母数"、"数字个数"、"空格个数"、"文章总字数";③输出删除某一字符串后的文章;选题三:构造有序顺序表要求:进一步完善SqList类模板,实现顺序表的按值插入元素,即顺序表为递增有序表,插入元素后仍递增有序。

方法:在sq_list.h中添加代码,在SqList类模板的定义中添加函数声明,在类模板实现部分实现该函数。

bool CreateListOrder();bool InsertOrder(ElemType e);三、实验步骤1.启动VC6.0:开始菜单→程序→Microsoft Visual Studio 6.0 →Microsoft Visual C++ 6.02.建立工程:文件(File)→新建(new)→在弹出的对话框中选择工程标签(Project)→选中选项:Win32 Console Application(不能选别的)→输入工程名(Project Name)→选择工程的存放位置(Location)→单击“确定”按钮(OK)→在弹出的对话框中选中选项:An Empty Project→单击“完成”按钮(Finish)→在弹出的对话框中单击“确定”按钮( OK )。

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

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

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

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

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

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

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

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

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

集合的并、交和差运算的算法

集合的并、交和差运算的算法

<数据结构>课程设计题目:(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;}。

数据结构课程设计报告--集合的并、交和差运算

数据结构课程设计报告--集合的并、交和差运算

题目:集合的并、交和差运算【问题描述】编制一个能演示执行集合的并、交和差运算的程序。

【基本要求】(1) 集合的元素限定为小写字母字符[‘a’..’z’] 。

(2) 演示程序以用户和计算机的对话方式执行。

【测试数据】(1)Set1="magazine",Set2="paper",Set1∪Set2="aegimnprz",Setl ∩Set2="ae",Set1-Set2="gimnz"。

(2)Set1= " 012oper4a6tion89",Set2="error data",Set1∪Set2="adeinoprt",Setl ∩Set2="aeort",Set1-Set2="inp"。

【实现提示】以有序链表表示集合。

【选作内容】(1) 集合的元素判定和子集判定运算。

(2) 求集合的补集。

(3) 集合的混合运算表达式求值。

(4) 集合的元素类型推广到其他类型,甚至任意类型。

一、实验内容实验题目:编制一个演示集合的并、交和差运算的程序。

需求分析:1、本演示程序中,集合的元素限定为小写字母字符[“a”…”z”]。

集合输入的形式为一个以“回车符“为结束标志的字符串,串中字符顺序不限。

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

3、程序执行的命令包括:1)构造集合1;2)构造在集合2;3)求并集;4)求交集;5)求差集;6)返回;7)结束。

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

二、数据结构设计为了实现上述程序的功能,应以有序链表表示集合。

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

集合的并,交和差运算数据结构C 课程设计

集合的并,交和差运算数据结构C  课程设计

数据结构C++课程设计题目: 集合的并、交和差运算一、设计题目集合的并、交和差运算二、小组成员分工说明一个人三、需求分析1)运行环境(软、硬件环境)软件环境:Microsoft Vista操作系统,Visual C++ 6.0硬件环境:2.0GB内存2)输入的形式和输入值的范围运行所给的测试数据,集合的元素限定为小写字符〔a. .z〕:第一组: Set1=magazine ,Set2=paper第二组: Set1=0120per4a6tion89,Set2=error data输出的形式描述程序运行并、交和差运算后得到数据,输出字符。

3)功能描述能演示执行集合的并、交和差运算。

4)测试数据(1) Set1=magazine ,Set2=paper,Set1∪Set2=aeginmprz,Set1∩Set2=ae,Set1-Set2=gimnz。

(2) Set1=0120per4a6tion89,Set2=error data,Set1∪Set2=adeinoprt,Set1∩Set2=aeort,Set1-Set2=inp。

四、概要设计1)抽象数据类型定义描述(顺序表的抽象数据类型描述)ADT Seqlist isData线性表的长度OperationSeqlist初始化值:无动作:置顺序表的长度为0Length输入:无前置条件:表已存在功能:求表的长度输出:返回表的长度,即表中数据元素的个数后置条件:表不变Get输入:元素的序号i前置条件:表已存在,i合法功能:在表中取序号为i的数据元素输出:若i合法,返回序号为i的元素值,否则抛出异常后置条件:表不变Locate输入:数据元素item前置条件:表已存在功能:在线性表中查找值等于item的元素输出:若查找成功,返回x在表中的序号,否则返回0 后置条件:表不变Insert输入:插入位置i;待插元素item前置条件:表已存在,i合法功能:在表的第i个位置处插入一个新元素x输出:若插入不成功,抛出异常后置条件:若插入成功,表中增加一个新元素Delete输入:删除位置i前置条件:表已存在功能:删除表中的第i个元素输出:若删除成功,返回被删元素,否则抛出异常后置条件:若删除成功,表中减少一个元素Empty输入:无前置条件:表已存在功能:判断表是否为空输出:若是空表,返回1,否则返回0后置条件:表不变Clear输入:无前置条件:无功能:清空顺序表输出:无后置条件:表的长度是0end ADT seqList2)功能模块设计(如主程序模块设计)集合的并、交和差运算集合的并运算集合的交运算集合的差运算3)模块层次调用关系图mainbin jiao cha五、详细设计实现概要设计中定义的所有的类的定义及类中成员函数,并对主要的模块写出伪码算法。

课程设计报告集合的交并差运算

课程设计报告集合的交并差运算

兰州商学院陇桥学院工学系课程设计报告设计题目:集合的交、并、差运算系别:工学系专业 (方向):信息管理与信息系统年级、班:20XX级(X)班学生姓名:张某某学生学号:000000000000指导教师:王某某20xx年 00月 00日目录一、系统开发的背景 (1)二、系统分析与设计 (1)(一)系统功能要求 (1)1、输入集合1中的元素; (1)2、输入集合2中的元素; (1)3、执行交集、并集、差集运算; (1)(二)系统模块结构设计 (1)1、集合的交集运算, (1)2、集合的并集运算, (2)3、集合的差集运算, (2)三、系统的设计与实现 (2)(一)集合的交集运算:VOID JIAO() (2)(二)集合的并集运算:VOID BING() (3)(三)集合的差集运算:VOID CHA() (4)四、系统测试 (5)(一)测试MAIN()函数 (5)(二)测试VOID JIAO()函数 (5)(三)测试VOID BING()函数 (5)(四)测试VOID CHA()函数 (5)五、总结 (6)六、附件(代码、部分图表) (7)集合的交、并、差运算一、系统开发的背景为了演示执行集合的交、并和差运算的程序,因此设计了这个程序。

二、系统分析与设计(一)系统功能要求可以对键盘输入的集合元素进行反序输出,然后对输入的集合进行交集,并集,差集的运算。

1、输入集合1中的元素;2、输入集合2中的元素;3、执行交集、并集、差集运算;(二)系统模块结构设计通过对系统功能的分析,集合交并差系统功能如图1所示。

图1 集合的交并差运算系统功能图通过上图的功能分析,把整个系统划分为3个模块:1、集合的交集运算,该模块主要实现:找出集合1与集合2中相同的元素并输出,借助函数void jiao()来实现;2、集合的并集运算,该模块主要实现:将集合1与集合2中的元素集中于一起,并且全部输出,借助函数void bing()来实现;3、集合的差集运算,该模块主要实现:集合1减去集合2输出所得结果;集合2减去集合1输出所得结果, 借助函数void cha()来实现。

并交和差运算

并交和差运算

编制一个能演示执行集合的并、交和差运算的程序。

集合的元素限定为小写字母字符[‘a’..’z’],演示程序以用户和计算机的对话方式执行,如:输入集合1数据“book”和集合2数据“bag”,则输出两个集合的并集是“abgko”,两个集合的交集是“b”,两个集合的差集是“ko”。

#include "C:\Sqlist.cpp"//注意把Sqlist.cpp文件放入c盘根目录下#include<iostream.h>#include<string.h>void UnionList(SqList *LA,SqList *LB,SqList *&LC)//并集{int i=0,j=0,k=0; //i、j、k分别作为LA、LB、LC的下标LC=(SqList *)malloc(sizeof(SqList));LC->length=0;while (i<LA->length && j<LB->length){if (LA->data[i]<LB->data[j]){LC->data[k]=LA->data[i];i++;k++;}else if(LA->data[i]==LB->data[j]){LC->data[k]=LA->data[i];i++;k++;j++;}else if(LA->data[i]>LB->data[j]){LC->data[k]=LB->data[j];k++;j++;}}while (i<LA->length) //LA尚未扫描完,将其余元素插入LC中{LC->data[k]=LA->data[i];i++;k++;}while (j<LB->length) //LB尚未扫描完,将其余元素插入LC中{LC->data[k]=LB->data[j];j++;k++;}LC->length=k;}void Commnode(SqList *LA,SqList *LB,SqList *&LC)//交集{int i=0,j=0,k=0;LC=(SqList *)malloc(sizeof(SqList));LC->length=0;while(i<LA->length&&j<LB->length){if(LA->data[i]<LB->data[j]){i++;}else if(LA->data[i]==LB->data[j]){LC->data[k]=LA->data[i];i++;j++;k++;}else if(LA->data[i]>LB->data[j]){j++;}}LC->length=k;}void Subtraction(SqList *LA,SqList *LB,SqList *&LC)//差集{int i=0,j=0,k=0;LC=(SqList *)malloc(sizeof(SqList));LC->length=0;while(i<LA->length&&j<LB->length){if(LA->data[i]<LB->data[j]){LC->data[k]=LA->data[i];i++;k++;}else if(LA->data[i]==LB->data[j]){i++;j++;}else if(LA->data[i]>LB->data[j]) {LC->data[k]=LB->data[j];j++; k++;}}while(i<LA->length){LC->data[k]=LA->data[i];i++;k++;}while(j<LB->length){LC->data[k]=LB->data[j];j++;k++;}LC->length=k;}void main(){ char a[10],b[10];SqList *L1,*L2,*L3;int a1,b1;InitList(L1);InitList(L2);InitList(L3);int A=0;do{cout<<"请输入集合A:";cin>>a;a1=strlen(a);for(int i=0;i<a1;i++)ListInsert(L1,a[i]);if(a1>ListLength(L1)){cout<<"注意 ! 元素有重复"<<endl; DestroyList(L1);InitList(L1);}else if(a1==ListLength(L1))A=1; }while(A==0);int B=0;do{cout<<"请输入集合B:";cin>>b;b1=strlen(b);for(int j=0;j<b1;j++)ListInsert(L2,b[j]);if(b1>ListLength(L2)){cout<<"注意 ! 元素有重复"<<endl; DestroyList(L2);InitList(L2);}else if(b1==ListLength(L2)) B=1;}while(B==0);cout<<"集合A的长度:"<<a1<<endl;cout<<"集合B的长度:"<<b1<<endl;cout<<"集合A在顺序表中的结构:"<<endl; DispList(L1);cout<<"集合B在顺序表中的结构:"<<endl; DispList(L2);cout<<"并集:"<<endl;UnionList(L1,L2,L3);DispList(L3);cout<<"交集:"<<endl;Commnode(L1,L2,L3);DispList(L3);cout<<"差集:"<<endl;Subtraction(L1,L2,L3);DispList(L3);}//Sqlist.cpp文件#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ ElemType data[MaxSize]; //存放顺序表元素int length; //存放顺序表的长度} SqList; //顺序表的类型定义void CreateList(SqList *&L,ElemType a[],int n) //建立顺序表{int i;L=(SqList *)malloc(sizeof(SqList));for (i=0;i<n;i++)L->data[i]=a[i];L->length=n;}void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0;}void DestroyList(SqList *&L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->data[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->data[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; //将顺序表位序转化为elem下标for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;L->length++; //顺序表长度增1return 1;}int ListInsert(SqList *&L,ElemType e){int i=0,j;while(i<L->length&&L->data[i]<e)i++;if(L->data[i]==e)return 0;for(j=ListLength(L);j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;L->length++; //顺序表长度增1return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; //将顺序表位序转化为elem下标e=L->data[i];for (j=i;j<L->length-1;j++) //将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--; //顺序表长度减1return 1;}#include<stdio.h>#include<string.h>#include<stdlib.h>#define TRUE 1#define FORSE 0typedef char ElemType;typedef struct ElemNode{ElemType elem;struct ElemNode* next;}*Set;int main(){/*---------FunctionList-----------------------*/int LenghOf(ElemNode src); /*返回一个集合的长度*/void CreateSet(Set dest); /*创建一个新的字母集合限定a-z*/void EmptySet(Set dest); /*清空一个集合,保留头结点*/void DestroySet(Set dest); /*销毁集合*/void DisplaySet(ElemNode src); /*打印集合的所有元素*/void AddElem(Set dest,ElemType e); /*在链表尾部追加一个元素*/void DelElem(Set dest,ElemType e); /*删除集合中的一个元素一次*/int ExistElem(ElemNode src,ElemType e); /*判断元素是否存在于集合中*/ void ContactSet(Set dest,ElemNode src); /*连接一个集合到另一个集合*/ void MulSet(Set dest,ElemNode src1,ElemNode src2); /*集合交运算*/void AddSet(Set dest,ElemNode src1,ElemNode src2); /*集合并运算*/void SubSet(Set dest,ElemNode src1,ElemNode src2); /*集合差运算*/ElemNode a,b,c;ElemType ch;printf("输入一个小写字母集合:\n");printf("Set1 = ");CreateSet(&a);printf("再输入一个小写字母集合:\n");printf("Set2 = ");CreateSet(&b);printf("交运算:*\n");printf("并运算:+\n");printf("差运算:-\n");printf("结束:end\n");while(1){printf("\n输入操作符:");scanf("%c",&ch);getchar();DisplaySet(a);DisplaySet(b);if(ch=='*'){MulSet(&c,a,b);printf("运算结果:");DisplaySet(c);}if(ch=='+'){AddSet(&c,a,b);printf("运算结果:");DisplaySet(c);}if(ch=='-'){SubSet(&c,a,b);printf("运算结果:");DisplaySet(c);}if(ch=='e'){break;}}EmptySet(&a);/*回收内存*/EmptySet(&b);/*回收内存*/EmptySet(&c);/*回收内存*/return 0;}/*返回一个集合的长度*/int LenghOf(ElemNode src){int i=0;while(src.next!=NULL){i++;src=*(src.next); /*改变src的值不会改变原来的链表结构*/ }return i; /*返回长度*/}/*创建一个新的字母集合限定a-z*/void CreateSet(Set dest){ElemType ch;Set p,n;p=dest;p->elem='A';while(1){ch=getchar();if(ch=='\n'){break;}if(ch<97||ch>122){continue;}n=(Set)malloc(sizeof(ElemNode)); p->next=n;n->elem=ch;p=n;}n->next=NULL;return;}/*清空一个集合,保留头结点*/void EmptySet(Set dest){Set p,n;p=dest->next;while(p!=NULL){n=p;p=p->next;free(n);}dest->next=NULL;return;}/*销毁集合*/void DestroySet(Set dest){EmptySet(dest);free(dest);return;}/*打印集合的所有元素*/void DisplaySet(ElemNode src){while(src.next!=NULL){src=*(src.next);printf("%c; ",src.elem);}printf("\n");return;}/*在链表尾部追加一个元素*/void AddElem(Set dest,ElemType e){Set p;p=dest;while(p->next!=NULL){p=p->next;}p->next=(Set)malloc(sizeof(ElemNode)); p=p->next;p->elem=e;p->next=NULL;return;}。

数据结构(C语言版)实验报告-集合的交并差

数据结构(C语言版)实验报告-集合的交并差

《数据结构与算法》实验报告一、需求分析问题描述:编制一个能演示执行集合的并、交和差运算的程序基本要求:集合元素限定为小写字母[’a’…’z’];演示程序以用户和计算机对话方式执行。

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

计算机终端中显示提示信息之后,由用户自行选择下一步命令,相应输入数据和运算结果在其后显示。

数据测试:(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.定义顺序表typedef struct SET{char *elem;int size;int length;}set;2 基本操作:set InitSet(set s);//初始化集合set Input(set s);//向集合中输入元素set InsertSet(set s, char e);//向集合中插入元素set DelateSet(set s,int n);//从集合中删除元素void display(set s);//显示集合set SetMix(set set1,set set2,set set3);//求集合的交集set check(set s);//检查集合中是否有数字或者重复字母set Sort(set s);//对集合中的元素进行排序三、详细设计1.头文件#include<stdio.h>#include<stdlib.h>#include<string.h>2.定义#define MAX_SIZE 20(顺序表的初始大小)#define ADD_SIZE 10(顺序表的递增大小)3.结构类型typedef struct SET{char *elem;int size;int length;}set;4. 初始化集合set InitSet(set s){s.elem=(char*)malloc(MAX_SIZE*sizeof(char));s.size=MAX_SIZE;s.length=0;return s;}5. 向集合中输入元素set Input(set s){char *newbase;gets(s.elem);s.length+=strlen(s.elem);if(s.size<=s.length){newbase=(char*)realloc(s.elem,(s.size+ADD_SIZE)*sizeof(char));s.elem=newbase;s.size+=ADD_SIZE;}return s;}6.向集合中插入元素set InsertSet(set s,char e){s.elem[s.length]=e;s.elem[s.length+1]='\0';s.length++;return s;}7.从集合中删除元素set DelateSet(set s,int n){int i;for(i=n;i<=s.length;i++){s.elem[i-1]=s.elem[i];}s.length--;return s;}8.显示集合void display(set s){puts(s.elem);}9.检查集合中是否有数字或者重复字母set check(set s){int i,j,count;for(i=1;i<=s.length;i++){for(j=1;j<i;j++){if(s.elem[i-1]==s.elem[j-1]){s=DelateSet(s,i);i--;break;}}}for(i=1;i<=s.length;i++){if(s.elem[i-1]>'z'||s.elem[i-1]<'a'){s=DelateSet(s,i);i--;}}return s;}10.求集合的并集set SetMix(set set1,set set2,set set3){int i;for(i=1;i<=set1.length;i++){set3=InsertSet(set3,set1.elem[i-1]);}for(i=1;i<=set2.length;i++){set3=InsertSet(set3,set2.elem[i-1]);}set3=check(set3);set3=Sort(set3);return set3;}11.求集合的交集set SetSame(set set1,set set2,set set3){int i,j;for(i=1;i<=set1.length;i++){for(j=1;j<set2.length;j++){if(set1.elem[i-1]==set2.elem[j-1]){set3=InsertSet(set3,set1.elem[i-1]);break;}}}set3=check(set3);set3=Sort(set3);return set3;}12.求集合的差set SetReduce(set set1,set set2,set set3){int i,j;for(i=1;i<=set1.length;i++){set3=InsertSet(set3,set1.elem[i-1]);}for(i=1;i<=set3.length;i++){for(j=1;j<set2.length;j++){if(set3.elem[i-1]==set2.elem[j-1]){set3=DelateSet(set3,i);}}}set3=check(set3);set3=Sort(set3);return set3;}set Sort(set s){int i,j;char temp;for(i=0;i<s.length-1;i++){for(j=0;j<s.length-i-1;j++){if(s.elem[j]>s.elem[j+1]){temp=s.elem[j];s.elem[j]=s.elem[j+1];s.elem[j+1]=temp;}}}return s;}13.主程序main(){int i;set set1,set2,set3;set1=InitSet(set1);printf("输入第一个集合:");set1=Input(set1);set2=InitSet(set2);printf("输入第二个集合:");set2=Input(set2);set3=InitSet(set3);printf("选择要进行的操作:1、求交集 2、求并集 3、求集合的差:");scanf("%d",&i);if(i==1){set3=SetSame(set1,set2,set3);set3=check(set3);set3=Sort(set3);printf("交集为:");display(set3);}else if(i==2){printf("并集为:");set3=SetMix(set1,set2,set3);set3=check(set3);set3=Sort(set3);display(set3);}else if(i==3){printf("集合的差:");set3=SetReduce(set1,set2,set3);set3=check(set3);set3=Sort(set3);display(set3);}elseprintf("输入错误");return 0;}四、调试分析1.本程序的模块划分比较合理,且尽可能的将指针的操作封装在结点和链表的两个模块中,致使集合模块的调试比较成功。

数据结构 集合的并、交和差运算

数据结构 集合的并、交和差运算

实验二:集合的并、交和差运算题目:集合的并、交和差运算基本功能编制一个能演示执行集合的并、交和差运算的程序。

基本要求:(1)集合的元素限定为小写字母字符[‘a’…‘z’];(2)演示程序以用户和计算机的对话方式执行。

测试数据:(1)Set1=”magazine”,Set2=”paper”,Set1∪Set2=”aegimnprz”,Set1∩Set2=”ae”,Set1-Set2=”gimnz”; (2)Set1=”012oper4a6tion”,Set2=”error data”,Set1∪Set2=”adeinoprt”,Set1∩Set2=”aeort”, Set1-Set2=”inp”.算法思想:设有集合Set1、Set2,Set1与BSet2的交集为Set1∩Set2。

Set1∩Set2指既属于集合Set1又属于集合BSet2的元素。

因为要求另外申请存储空间,可另找一个新的集合Set1∩Set2中存储A和B共同的元素。

问题即变为求找Set1和Set2中的共同思想。

于是算法思想为:以Set1为标准,对Set2进行遍历,把Set2中和Set1相同的元素存储到Set1∩Set2中。

为方便操作,链表需要设置头结点。

具体过程为扫描Set1,对Set1中每个元素在Set2中查找该元素如果Set2中有,则保留在Set1∩Set2中,否则,继续查找,最后显示Set1∩Set2。

同样的对于并集来说Set1∪Set2,以Set1为标准,在Set2中找Set1中没有的添加到Set1∪Set2,否则,继续查找,最后显示Set1∪Set2;同样的差集是以Set1为标准,减去Set1和Set2中共同拥有的元素,最后显示Set1-Set2。

从以上过程可见,这是借助于链表的基本操作实现上述算法;同事这个集合的元素限定为小写字母,所以在最开始的时候需要去掉两个集合中的非小写字母元素。

模块划分:数据结构:源程序:序设计正确。

数据结构课程设计选题

数据结构课程设计选题

数据结构课程设计选题题目选题一:迷宫与栈问题【问题描述】以一个mXn的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。

设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

【任务要求】1)首先实现一个以链表作存储结构的栈类型,然后编写一个求解迷宫的非递归程序。

求得的通路以三元组(i,j,d)的形式输出。

其中:(i,j)指示迷宫中的一个坐标,d表示走到下一坐标的方向。

如,对于下列数据的迷宫,输出一条通路为:(1,1,1),(1,2,2),(2,2,2),(3,2,3),(3,1,2),…。

2)编写递归形式的算法,求得迷宫中所有可能的通路。

3)以方阵形式输出迷宫及其通路。

【测试数据】迷宫的测试数据如下:左上角(0,1)为入口,右下角(8,9)为出口。

出口出口选题二:算术表达式与二叉树【问题描述】一个表达式和一棵二叉树之间,存在着自然的对应关系。

写一个程序,实现基于二叉树表示的算术表达式的操作。

【任务要求】假设算术表达式Expression内可以含有变量(a~z)、常量(0~9)和二元运算符(+,-,*,/,^(乘幂))。

实现以下操作:1)ReadExpre(E)—以字符序列的形式输入语法正确的前缀表达式并构造表达式E。

2)WriteExpre(E)—用带括弧的中缀表达式输出表达式E。

3)Assign(V,c)—实现对变量V的赋值(V=c),变量的初值为0。

4)Value(E)—对算术表达式E求值。

5)CompoundExpr(P,E1,E2)--构造一个新的复合表达式(E1)P(E2)【测试数据】1)分别输入0;a;-91;+a*bc;+*5^x2*8x;+++*3^x3*2^x2x6并输出。

2)每当输入一个表达式后,对其中的变量赋值,然后对表达式求值。

选题三:银行业务模拟与离散事件模拟【问题描述】假设某银行有4个窗口对外接待客户,从早晨银行开门(开门9:00am,关门5:00pm)起不断有客户进入银行。

编制一个能演示执行集合的交、并和差运算的程序

编制一个能演示执行集合的交、并和差运算的程序

编制一个能演示执行集合的交、并和差运算的程序。

#include<iostream>using namespace std;typedef struct Node{char data;Node *next;}Node,*LinkList;#define SIZE sizeof(Node)#define FALSE 0#define TRUE 1//初始化集合void InitLinkList(LinkList Head){char ch;Node *p=Head;Head->next=NULL;Head->data='\0';cin>>ch;while(ch!='#'){Node *newNode=(Node*)malloc(SIZE);newNode->data=ch;p->next=newNode;p=p->next;cin>>ch;}p->next=NULL;}//检查p1或p2所指向数据结点该不该加入到Head为起始的集合中^-^有点拗口,表达不是很好int Check(char ch,LinkList Head){Node *temp=Head->next;int flag=TRUE;while(temp!=NULL){if(temp->data==ch){//不需要将数据插入flag=FALSE;return flag;}temp=temp->next;}return flag;}//合并两个集合LinkList Merge(LinkList Head1,LinkList Head2) {LinkList Head=(Node*)malloc(SIZE);Head->data='\0';Head->next=NULL;Node *p1=Head1->next;Node *p2=Head2->next;Node *p=Head;while(p1!=NULL&&p2!=NULL){if(p1->data==p2->data){if(Check(p1->data,Head)==TRUE){Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;p->next=newNode;p=newNode;p->next=NULL;}}else{if(Check(p1->data,Head)==TRUE){Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;p->next=newNode;p=newNode;p->next=NULL;}if(Check(p2->data,Head)==TRUE){Node *newNode=(Node*)malloc(SIZE);newNode->data=p2->data;p->next=newNode;p=newNode;p->next=NULL;}}p1=p1->next;p2=p2->next;}while(p1!=NULL){if(Check(p1->data,Head)==TRUE) {Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;p->next=newNode;p=newNode;p->next=NULL;}p1=p1->next;}while(p2!=NULL){if(Check(p2->data,Head)==TRUE) {Node *newNode=(Node*)malloc(SIZE); newNode->data=p2->data;p->next=newNode;p=newNode;p->next=NULL;}p2=p2->next;}return Head;}//集合A中的元素,B中是否存在int IsExist(char data,LinkList Head) {Node *p=Head->next;int flag=FALSE;while(p!=NULL){if(p->data==data)return flag=TRUE;p=p->next;}return flag;}int IsExist2(char data,LinkList Head){Node *p=Head->next;int flag=FALSE;while(p!=NULL){if(p->data==data)return flag;p=p->next;}return flag=TRUE;}//两个集合的差集LinkList Deprive(LinkList Head1,LinkList Head2) {LinkList Head=(Node*)malloc(SIZE);Node *p=Head;Node *p1=Head1->next;while(p1!=NULL){if(IsExist2(p1->data,Head2)==1){Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;p->next=newNode;p=newNode;p->next=NULL;}p1=p1->next;}return Head;}//两个集合交集LinkList Insection(LinkList Head1,LinkList Head2){Node *p1=Head1->next;//Node *p2=Head2->next;LinkList Head=(Node*)malloc(SIZE);Head->data='\0';Head->next=NULL;Node *p=Head;while(p1!=NULL){if(IsExist(p1->data,Head2)==1){Node *newNode=(Node*)malloc(SIZE);newNode->data=p1->data;p->next=newNode;p=newNode;p->next=NULL;}p1=p1->next;}return Head;}//打印集合元素void PrintLinkList(LinkList Head){Node *p=Head->next;while(p!=NULL){cout<<p->data;p=p->next;}cout<<"\n";}int main(){char cmd;do{cout<<"输入两个集合的元素,输完一个集合的元素,按#结束\n";LinkList head1=(Node*)malloc(SIZE); LinkList head2=(Node*)malloc(SIZE); InitLinkList(head1);InitLinkList(head2); Node *Head1=Merge(head1,head2); cout<<"两个集合合集为\n"; PrintLinkList(Head1);Node *Head2=Insection(head1,head2); cout<<"两个集合交集为\n"; PrintLinkList(Head2);Node *Head3=Deprive(head1,head2); cout<<"两个集合差集为\n"; PrintLinkList(Head3);cout<<"按y/Y继续,否则结束\n"; cin>>cmd;}while(cmd=='y'||cmd=='Y');return 0;}。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

编制一个能演示执行集合的交、并和差运算的程序。

#include<iostream>
using namespace std;
typedef struct Node{
char data;
Node *next;
}Node,*LinkList;
#define SIZE sizeof(Node)
#define FALSE 0
#define TRUE 1
//初始化集合
void InitLinkList(LinkList Head)
{
char ch;Node *p=Head;
Head->next=NULL;
Head->data='\0';
cin>>ch;
while(ch!='#')
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=ch;
p->next=newNode;
p=p->next;
cin>>ch;
}
p->next=NULL;
}
//检查p1或p2所指向数据结点该不该加入到Head为起始的集合中^-^有点拗口,表达不是很好
int Check(char ch,LinkList Head)
{
Node *temp=Head->next;
int flag=TRUE;
while(temp!=NULL)
{
if(temp->data==ch){//不需要将数据插入
flag=FALSE;
return flag;
}
temp=temp->next;
}
return flag;
}
//合并两个集合
LinkList Merge(LinkList Head1,LinkList Head2) {
LinkList Head=(Node*)malloc(SIZE);
Head->data='\0';Head->next=NULL;
Node *p1=Head1->next;
Node *p2=Head2->next;
Node *p=Head;
while(p1!=NULL&&p2!=NULL)
{
if(p1->data==p2->data)
{
if(Check(p1->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
}
else
{
if(Check(p1->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
if(Check(p2->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p2->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
}
p1=p1->next;
p2=p2->next;
}
while(p1!=NULL)
{
if(Check(p1->data,Head)==TRUE) {
Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
p1=p1->next;
}
while(p2!=NULL)
{
if(Check(p2->data,Head)==TRUE) {
Node *newNode=(Node*)malloc(SIZE); newNode->data=p2->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
p2=p2->next;
}
return Head;
}
//集合A中的元素,B中是否存在
int IsExist(char data,LinkList Head) {
Node *p=Head->next;
int flag=FALSE;
while(p!=NULL)
{
if(p->data==data)
return flag=TRUE;
p=p->next;
}
return flag;
}
int IsExist2(char data,LinkList Head)
{
Node *p=Head->next;
int flag=FALSE;
while(p!=NULL)
{
if(p->data==data)
return flag;
p=p->next;
}
return flag=TRUE;
}
//两个集合的差集
LinkList Deprive(LinkList Head1,LinkList Head2) {
LinkList Head=(Node*)malloc(SIZE);
Node *p=Head;
Node *p1=Head1->next;
while(p1!=NULL)
{
if(IsExist2(p1->data,Head2)==1)
{
Node *newNode=(Node*)malloc(SIZE); newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
p1=p1->next;
}
return Head;
}
//两个集合交集
LinkList Insection(LinkList Head1,LinkList Head2)
{
Node *p1=Head1->next;
//Node *p2=Head2->next;
LinkList Head=(Node*)malloc(SIZE);
Head->data='\0';Head->next=NULL;
Node *p=Head;
while(p1!=NULL)
{
if(IsExist(p1->data,Head2)==1)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
p1=p1->next;
}
return Head;
}
//打印集合元素
void PrintLinkList(LinkList Head)
{
Node *p=Head->next;
while(p!=NULL)
{
cout<<p->data;
p=p->next;
}
cout<<"\n";
}
int main()
{
char cmd;
do{
cout<<"输入两个集合的元素,输完一个集合的元素,按#结束\n";
LinkList head1=(Node*)malloc(SIZE); LinkList head2=(Node*)malloc(SIZE); InitLinkList(head1);InitLinkList(head2); Node *Head1=Merge(head1,head2); cout<<"两个集合合集为\n"; PrintLinkList(Head1);
Node *Head2=Insection(head1,head2); cout<<"两个集合交集为\n"; PrintLinkList(Head2);
Node *Head3=Deprive(head1,head2); cout<<"两个集合差集为\n"; PrintLinkList(Head3);
cout<<"按y/Y继续,否则结束\n"; cin>>cmd;
}while(cmd=='y'||cmd=='Y');
return 0;
}。

相关文档
最新文档