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

合集下载

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

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

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

集合的交并差运算

集合的交并差运算
int d;
cin>>d;
int n;n=ListLength(i);
LinkList *p,*q;
int j;
char s;
while(d<1 || d>n)
{
cout<<"对不起!您输入的位置有误,请重新输入!"<<endl;
cin>>d;
}
j=0;
p=a[i].L;
while(j<d-1)
{
p=p->next;
LinkList *L;
public:
jihe()
{
L=(LinkList*)malloc(sizeof(LinkList));
length=0;
L->next=NULL;
}
~jihe()
{
LinkList *p;
while (L->next)
{
p = L->next;
L->next = p->next;
if(c==' ')
{}
else
{
p->data=c;
r->next=p;
r=p;
}
c=cin.get();
}
r->next=NULL;
cout<<"输入完毕,请按回车键返回主菜单!"<<endl;
getchar();
}
/*****************************输出***********************************/
3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力

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

数据结构课设报告_集合的并、交和差运算的程序
1.void InitSet(Set &Res)
操作结果:初始化集合的函数,函数参数为引用类型。
2.Set DealSet(char *s)
初始条件:指针s不为空
操作结果:将字符串处理成集合,生成的集合为函数返回值。
3.void PriSet(Set s)
操作结果:打印集合s。
4.Set Jiao(Set sa,Set sb)
3.void PriSet(Set s):
输出集合s,首先输出左花括号’{’,之后使用for循环遍历整个hash数组,如果hash数组的值为真,则说明该集合包含此项元素,输出该元素加空格,之后再输出右花括号’}’。
4.Set Jiao(Set sa,Set sb)
定义两个形参集合sa和sb,遍历两个集合的hash数组,如果两个hash数组的值同时为真,则说明sa和sb集合都含有该元素,则将该元素加入函数之中定义的Res集合,并将Res集合的元素个数加一。在程序最后返回Res集合的值。
Res.num=0;//元素个数为0
}
Set DealSet(char *s)//将字符串处理成集合
{
Set Res;//函数返回的集合
InitSet(Res);//初始化集合
for (int i=0;i<strlen(s);i++)//遍历整个字符串
{
if (s[i]>='a' && s[i]<='z')//在a到z之间,才符合集合元素范围
5.Set Bing(Set sa,Set sb)
和Jiao()函数类似,同样遍历hash数组,唯一不同的是判断hash数组的语句,只要sa和sb其中有一个的值为真,则加入到Res中。

数据结构课程设计_集合运算(完整).

数据结构课程设计_集合运算(完整).

电子与信息工程学院数据结构实验报告实验名称: 集合的运算实验类型:设计(验证、设计、创新)班级: 2013级电信三班学号: 201307014327 姓名:陆杰实验时间:2015 年 6 月16 日指导教师:余先伦成绩:目录一课程设计目的和要求二问题描述及分析三算法思想和程序的实现概述3.1 算法思想3.2 程序的实现概述四程序流程图流程图五程序的实现5.1 主函数5.2 链表的生成5.3 集合的输出5.4 并运算函数5.5交运算函数5.6 差函数六运行结果分析6.1 程序主界面6.2整数集合并运算6.3 整数集合交运算6.4 整数集合差运算6.5 字母集合并运算6.6 字母集合交运算6.7 字母集合差运算6.8 字母和数据集合并运算6.9 字母和数据集合交运算6.10 字母和数据集合差运算6.11 退出程序七源代码八总结九参考文献一课程设计目的和要求目的:深入理解数据结构的基本理论,掌握数据存储结构的设计方法,掌握基于数据结构的各种操作的实现方法,训练对基础知识和基本方法的综合运用能力,增强对算法的理解能力,提高软件设计能力。

在实践中培养独立分析问题和解决问题的作风和能力。

要求:熟练运用C++语言、基本数据结构和算法的基础知识,独立编制一个具有中等难度的、解决实际应用问题的应用程序。

通过题意分析、选择数据结构、算法设计、编制程序、调试程序、软件测试、结果分析、撰写课程设计报告等环节完成软件设计的全过程,不断地完善程序以提高程序的性能。

二问题描述及分析问题描述:本课程设计中,集合的元素可以是字母[a,b,…z],也可以是整数[0,1,…9],集合的大小集合输入的形式为一个以“回车符”为结束标志的字符,允许出现重复字符或非法字符,程序应能自动滤去。

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

问题描述:有两个集合A、B,要求它的交集、并集和差集C。

用两个链表p、q存储集合A、B,用链表r存储集合C。

集合的并交差运算

集合的并交差运算

石河子大学《集合的并,交和差运算》程序设计基础课程设计报告二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. 数组 2. 链表 3. 树 4. 图在编程中,通常使用数组或者链表来表示集合。

另外,树和图也可以表示集合,但在这里不做深入讨论。

三、集合的操作 1. 求并集求并集是指将两个集合中的所有元素合并成一个集合。

假设集合A和集合B分别表示为数组arrA和数组arrB,那么求并集的算法可以按照如下步骤进行:(1)创建一个空集合C。

(2)遍历数组arrA,将其中的元素逐个添加到集合C中。

(3)遍历数组arrB,对于其中的每个元素,先判断其是否已经在集合C中存在,如果不存在则将其添加到集合C中。

(4)返回集合C即为集合A和集合B的并集。

2.求交集求交集是指找出两个集合中共同拥有的元素。

假设集合A和集合B分别表示为数组arrA和数组arrB,求交集的算法可以按照如下步骤进行:(1)创建一个空集合C。

(2)遍历数组arrA,对于其中的每个元素,判断其是否同时存在于数组arrB中,如果是则将其添加到集合C中。

(3)返回集合C即为集合A和集合B的交集。

3.求差集求差集是指找出属于集合A但不属于集合B的元素。

假设集合A和集合B分别表示为数组arrA和数组arrB,求差集的算法可以按照如下步骤进行:(1)创建一个空集合C。

(2)遍历数组arrA,对于其中的每个元素,判断其是否同时存在于数组arrB中,如果不是则将其添加到集合C中。

(3)返回集合C即为集合A和集合B的差集。

四、实现下面,我们通过示例代码来展示如何在实际编程中实现集合的并集、交集和差集的算法。

# 求并集def union(arrA, arrB):setC = arrA.copy() # 将arrA复制给setCfor i in arrB:if i not in arrA:setC.append(i)return setC# 求交集def intersection(arrA, arrB):setC = []for i in arrA:if i in arrB:setC.append(i)return setC# 求差集def difference(arrA, arrB):setC = []for i in arrA:if i not in arrB:setC.append(i)return setC五、总结本文从数据结构的角度出发,探讨了求集合并集、交集、差集的算法及其实现。

数据结构课程设计_集合运算

数据结构课程设计_集合运算

数据结构课程设计_集合运算在计算机科学中,数据结构是组织和存储数据的方式,以便能够有效地对其进行操作和处理。

集合运算是数据结构课程中的一个重要部分,它涉及到对集合的各种操作,如并集、交集、差集等。

这些运算在许多实际应用中都有着广泛的用途,例如数据库管理、图像处理、算法设计等。

集合是由一组无序且唯一的元素组成的。

在编程中,我们可以使用不同的数据结构来实现集合,如数组、链表、哈希表等。

每种数据结构都有其特点和适用场景,选择合适的数据结构对于高效地执行集合运算至关重要。

让我们先来了解一下并集运算。

并集是指将两个集合中的所有元素合并在一起,去除重复的元素,得到一个新的集合。

例如,集合 A ={1, 2, 3},集合 B ={3, 4, 5},那么 A 和 B 的并集就是{1, 2, 3, 4, 5}。

在实现并集运算时,我们可以遍历两个集合,将元素依次添加到一个新的集合中。

在添加过程中,通过检查新集合中是否已经存在该元素来避免重复。

接下来是交集运算。

交集是指两个集合中共同拥有的元素所组成的集合。

对于上面的集合 A 和 B,它们的交集就是{3}。

实现交集运算时,我们可以同时遍历两个集合,只有当元素同时存在于两个集合中时,才将其添加到交集集合中。

差集运算则是从一个集合中去除另一个集合中的元素。

比如集合 A B 表示从集合 A 中去掉集合 B 中的元素,结果为{1, 2}。

在实现差集运算时,我们遍历第一个集合,对于每个元素,如果它不在第二个集合中,就将其添加到差集集合中。

在实际编程中,我们需要根据具体的问题和数据特点来选择合适的算法和数据结构来实现这些集合运算。

例如,如果集合中的元素数量较少,使用数组来存储集合可能是一个简单有效的选择。

但如果集合中的元素数量较大,且元素的值范围较广,哈希表可能是更好的选择,因为它可以提供更快的查找和插入操作。

为了更清晰地理解集合运算的实现,我们可以通过一个具体的例子来看看。

假设我们有两个学生名单集合,一个是参加数学竞赛的学生集合,另一个是参加物理竞赛的学生集合。

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

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

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

集合的并,交和差运算数据结构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五、详细设计实现概要设计中定义的所有的类的定义及类中成员函数,并对主要的模块写出伪码算法。

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

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

目录一.需求分析 (1)1.问题描述........................................................................................................... ............ (1)2.基本要求...................................................................................................................... .. (1)3.测试数据............................. . (1)4.实现提示........................................................................................ .. (1)二.概要设计 (1)1.数据类型定义 (1)2.集合的定义 (1)3.基本操作 (1)4.调用关系....................... ............................ ....................................................................... .. (2)三.详细设计 (3)1.具体算法流程 (4)2.具体的程序功能实现 (5)3.伪码算法 (5)四.调试分析 (9)1.调试过程中遇到的问题................................................................................................. (9)2.算法的时空分析 (10)3.经验和体会 (10)五.用户使用说明 (11)六.测试结果 (11)1.做完一次运算后按回车键继续下一次运算 (11)2.做完运算后输入字母“e”退出运算 (12)七.附录 (13)程序源代码...................................... ........................................................................... .. (13)一.需求分析1.问题描述编制一个能演示执行集合的并、交和差运算的程序。

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

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

兰州商学院陇桥学院工学系课程设计报告设计题目:集合的交、并、差运算系别:工学系专业 (方向):信息管理与信息系统年级、班: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()来实现。

集合的并、交和差运算

集合的并、交和差运算

集合的并、交和差运算
引言
在数学中,集合是由若干个元素组成的。

当我们处理集合时,会遇到三种基本的集合运算:并、交和差运算。

本文将介绍这三种运算的定义和性质。

集合的并运算
集合的并运算(union)指的是将两个或多个集合的所有元素合并成一个集合。

用符号∪表示。

对于给定的集合 A 和集合 B,它们的并集 A ∪ B 是包含了 A 和 B 中所有元素的集合。

集合的交运算
集合的交运算(intersection)指的是找到两个或多个集合中共有的元素,并将它们组成一个新的集合。

用符号∩ 表示。

对于给定的集合 A 和集合 B,它们的交集A ∩ B 是包含了 A 和 B 共有元素的集合。

集合的差运算
集合的差运算(difference)指的是从一个集合中减去另一个集合的元素,得到一个新的集合。

用符号 - 表示。

对于给定的集合 A 和集合 B,它们的差集 A - B 是包含了属于 A 但不属于 B 的元素的集合。

总结
通过并、交和差运算,我们可以对集合进行各种组合操作。

并集合并了两个或多个集合的元素,交集找到了两个或多个集合的共有元素,差集减去了一个集合中属于另一个集合的元素。

这些运算为我们处理集合提供了灵活性和多样性。

请注意,集合运算中的元素不会重复出现。

对于重复元素的处理,我们可以使用集合的扩展运算或计数运算进行处理。

参考资料
- 集合运算的定义和性质,《高等数学教程》
- 集合运算的应用,《离散数学》。

7集合的并、交、差操作

7集合的并、交、差操作

《数据结构与算法》课程设计任务书题目:集合的并、交、差操作学生姓名:学号:班级:题目类型:软件工程(R)指导教师:一.题目简介该设计要求学生设计程序,对集合中元素实现并、交、差等操作。

通过该题目的设计过程,可以进一步理解和熟练掌握课本中所学的各种数据结构,学会如何把学到的知识用于解决实际问题,培养学生的动手能力。

二.主要任务第一部分:基本算法实现1、线性结构基本算法实现(指导老师根据题目指定);2、树型结构基本算法实现(指导老师根据题目指定);3、图型结构基本算法实现(指导老师根据题目指定);4、查找基本算法实现(指导老师根据题目指定);5、排序基本算法实现(指导老师根据题目指定);第二部分:指定题目的设计与实现1、查阅文献资料,一般在3篇以上;2、建立数据的逻辑结构和物理结构;3、完成相应算法的设计;4、完成测试工作;5、撰写设计说明书;6、做好答辩工作。

三.主要内容、功能及技术指标(1)集合采用链表表示,主要功能有:求两个集合的并集、交集、差集、显示输出等,要求结果集合中的元素不重复;(2)利用随机函数产生100个随机整数作为测试数据,算法对于合法的输入数据都能产生满足规格说明要求的结果;(3)算法对于精心选择的典型、苛刻而带有刁难性的几组输入数据能够得出满足规格说明要求的结果;对算法实现过程中的异常情况能给出有效信息;(4)较高要求:输出界面的优化;求解集合的迪卡尔积。

四.提交的成果1. 设计说明书一份,内容包括:1) 中文摘要100字;关键词3-5个;2) 序言;3)采用类c语言定义相关的数据类型4)各模块的伪码算法5)函数的调用关系图6)调试分析a、调试中遇到的问题及对问题的解决方法;b、算法的时间复杂度和空间复杂度。

7)测试结果8)源程序(带注释)9) 设计总结、参考文献、致谢等。

2. 刻制光盘一张。

五.主要参考文献1.严蔚敏,吴伟民.《数据结构(C语言版)》.清华大学出版社.2.严蔚敏,吴伟民.《数据结构题集(C语言版)》.清华大学出版社.3 .《DATA STRUCTURE WITH C++》. William Ford,William Topp .清华大学出版社(影印版).4.谭浩强.《c语言程序设计》. 清华大学出版社.5.数据结构与算法分析(Java版) , A Practical Introduction to Data Structures and Algorithm Analysis Java Edition Clifford A. Shaffer , 张铭,刘晓丹译电子工业出版社 2001 年1月六.各阶段时间安排(共2周)2017年6月28日。

滨江学院 数据结构实习报告--集合的并交叉运算报告

滨江学院 数据结构实习报告--集合的并交叉运算报告

集合的并、交和差运算一、需求分析设计目的:通过集合运算的实现,熟练掌握线性表的基本操作在两种存储结构上的实现,其中以各种链表的操作和应用作为重点内容。

1.本演示程序中,集合的元素限制在小写字母‘a’-‘z’之间。

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

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

3.程序的执行命令有:1)选择操作2)任意键清屏二、概要设计三、详细设计#include <iostream> //C++输入输出流#include <List> //链表类using namespace std;#define DataTpye char//定义数据类型bool IsElementInList(list<DataTpye> aSet, DataTpye iElement)//查看iElement元素是否在aSet集合中{list<DataTpye>::iterator iter;for (iter = aSet.begin(); iter != aSet.end(); iter++)//遍历aSet单链表中的所有元素【后面同理】,直到找到与iElement元素相同的元素,返回true表明存在iElement元素{if (*iter == iElement) //在单链表中找到了与iElement元素相同的元素,此时开始执行if语句块{return true;}}//由于不满足for中的条件表明iElement元素在aSet中不存在return false;}void Trim(list<DataTpye> &aSet)//去除集合aSet中的重复元素{list<DataTpye> newSet;//在这里新创建一个单链表newSet,后面对aSet中的相同元素删除其仅剩一个为止,并放入newSetlist<DataTpye>::iterator iter;for (iter = aSet.begin(); iter != aSet.end(); iter++){if (!IsElementInList(newSet, *iter)&&(*iter>=97&&*iter<=122))//(*iter>=97&&*iter<=122)这是极其关键的一部分,它的作用是删除链表中的数字//在存储的时候数字是以字符的形式存储的,此时通过使用小写英文字母的ASCII码来限制入栈的元素{newSet.push_back(*iter);}}aSet = newSet;//操作进行完成将newSet有重新赋给aSet}void Union(list<DataTpye> set1, list<DataTpye> set2)//实现集合的并集运算,找出Set,Set_2中的所有元素{list<DataTpye> newSet = set1;list<DataTpye>::iterator iter;for (iter = set2.begin(); iter != set2.end(); iter++){if (IsElementInList(newSet, *iter)){continue;//在newSet中查找与iter相同的元素,如果if语句条件成立,表明IsElementInList()操作完成后返回了true//不做处理,跳出循环继续向后查找在newSet中查找与iter相同的元素}else{newSet.push_back(*iter);//if不满足条件表明是在set2中存在的元素而在set1中没有,此时入栈到newSet}}Trim(newSet);newSet.sort();//类中的方法,将单链表中的元素有序排列cout<<"集合的并操作结果是:"<<endl;cout<<"{";for (iter = newSet.begin(); iter != newSet.end(); iter++){cout<<*iter<<" ";}cout<<"}"<<endl;}void Inter(list<DataTpye> set1, list<DataTpye> set2)//实现集合的交集运算,找出Set,Set中的相同元素{list<DataTpye> newSet;list<DataTpye>::iterator iter;for (iter = set1.begin(); iter != set1.end(); iter++){if (IsElementInList(set2, *iter)){//在newSet中查找与iter相同的元素,如果if语句条件成立,表明IsElementInList()操作完成后返回了true//if条件成立找到了set2与set1相同的元素此时入栈到newSetnewSet.push_back(*iter);}else{continue;}}Trim(newSet);newSet.sort();cout<<"集合的交操作结果是:"<<endl;cout<<"{";for (iter = newSet.begin(); iter != newSet.end(); iter++){cout<<*iter<<" ";}cout<<"}"<<endl;}void Differ(list<DataTpye> set1, list<DataTpye> set2)//实现集合的差集运算,其本质是:在Set中找出与Set相同的元素将其删除{list<DataTpye> newSet;list<DataTpye>::iterator iter;for (iter = set1.begin(); iter != set1.end(); iter++){if (IsElementInList(set2, *iter)){//在set2中找出与iter相同的元素,不做入栈continue;}else{newSet.push_back(*iter);//将set1中与set2不相同的元素入栈到newSet,其意义就是作set1-set2}}Trim(newSet);newSet.sort();cout<<"集合的差操作结果是:"<<endl;cout<<"{";for (iter = newSet.begin(); iter != newSet.end(); iter++){cout<<*iter<<" ";}cout<<"}"<<endl;}int main(void){cout<<"输入集合Set1的元素,按'#'结束"<<endl;list<DataTpye> set1, set2;//定义两个单链表set1, set2用来实现测试数据元素的输入list<DataTpye>::iterator iter;DataTpye iIn = -1; //初始化输入的元素while ('#' != iIn) //用【#】来作为结束输入的结束标志{cin>>iIn;set1.push_back(iIn);}set1.pop_back();Trim(set1);set1.sort();cout<<"输入的集合set1是:"<<endl;cout<<"{";for (iter = set1.begin(); iter != set1.end(); iter++){cout<<*iter<<" ";}cout<<"}"<<endl;cout<<"输入集合set2的元素,按'#'结束"<<endl;iIn = -1; //回置数据标志while ('#' != iIn){cin>>iIn;set2.push_back(iIn);}set2.pop_back();Trim(set2);set2.sort();cout<<"输入的集合set2是:"<<endl;cout<<"{";for (iter = set2.begin(); iter != set2.end(); iter++){cout<<*iter<<" ";}cout<<"}"<<endl;here:cout<<"选择操作:1并集,2交集,3差集,0退出"<<endl;cin>>iIn;switch(iIn){case '1':Union(set1, set2);break;case '2':Inter(set1, set2);break;case '3':Differ(set1, set2);break;case '0':return 0 ;default:break;}goto here;}四、调试分析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。

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

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

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

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

实验报告题目:编制一个演示集合的并、交、和差运算的程序一、问题描述:设计一个程序,要求实现集合的并、交、和差的运算二、需求分析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是数据元素的判定函数。

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

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

编号:730数据结构与算法课程设计说明书集合的交并差运算学院:海洋信息工程学院专业:网络工程学生姓名:xx学号:xx指导教师:xx2017 年12 月21 日目录目录 (2)概述 (3)程序说明 (3)1 实验内容 (4)1.1实验目的 (4)1.2实验任务 (4)1.3要求 (4)2 数据结构设计及流程图 (5)2.1 抽象数据结构类型定义 (5)2.2本程序包含四个模块 (7)3 测试数据 (8)3.1源程序 (8)3.2测试数据及程序运行情况 (14)4 总结 (15)参考文献 (15)概述本演示程序的编写,主要运用的我们学的第二章《线性表》中的知识。

线性结构的特点是:在数据元素的非空有限集中,(1)存在唯一的一个被称做“第一个”的数据元素;(2)存在唯一的一个被称做“最后一个”的数据元素;(3)除第一个之外,集合中的每个数据元素均只有一个前驱;(4)除最后一个之外,集合中每个数据元素均只有一个后继。

本程序需要两个抽象数据类型:有序表和集合。

而且采用了单链表来实现。

一、程序说明本程序主要利用单链表及函数,实现集合的交集、并集和差集运算。

运行程序说明:菜单执行的命令包括<0-7> :<1>“请输入 A 集合的个数与A集合元素”<2>“请输入 B 集合个数与B集合的元素”<3>“A集合的有序集合”<4>“B集合的有序集合”<5>“AB集合的并集”<6>“AB集合的交集”<7>“AB集合的差集”<0>“退出” 注:展示程序中,集合元素限定为小写字母数据,以“回车键”束标志。

1、实验内容1.1 实验目的:设计一个演示集合的交、并、差的运算程序1.2 实验任务1) 使用单链表来表示集合,完成集合的交集、并集、差等操作。

2) 采用链表等数据结构。

3) 集合的元素限定为数字和小写的英文字母1.3 实验要求:1. 初步完成总体设计,建立头文件,确定函数个数。

(完整word版)数据结构课程设计_集合的并、交和差运算(2)

(完整word版)数据结构课程设计_集合的并、交和差运算(2)

数据结构课程设计报告设计题目专业计算机科学与技术班级____________学生张楠__________________学号___________ 3090911020 _________指导教师__________________起止时间2011.7.4〜2011.7.9 ______________.矽场并字22011年夏季学期目录1.实验内容实验题目:编制一个演示集合的并、交运算的程序。

题目:集合运算功能:使用链表来表示集合,完成集合的合并,求交集等操作。

分步实施:1.初步完成总体设计,搭好框架,确定人机对话的界面,确定函数个数;2.完成最低要求:3.进一步要求:要求:1)界面友好,函数功能要划分好2)总体设计应画一流程图3)程序要加必要的注释4)要提供程序测试方案1)程序一定要经得起测试,宁可功能少一些,也要能运行起来,不能运行的程序是没有价值的。

需求分析:1、本演示程序中,集合的元素限定为整形数据。

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

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

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

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

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

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

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

output(linklist I)初始条件:I是以I为头节点的非空链表。

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

2、集合的抽象数据类型定义为:heji(linklist A,linklist B,linklist C)初始条件:链表A、B、C已存在操作结果:生成一个由A和B的并集构成的集合C ojiaoji(linklist A,linklist B ,linklist ,C)初始条件:链表A、B、C已存在操作结果:生成一个由A和B的交集构成的集合 C 3、本程序抱含四个模块:1)节点结构单元模块——定义有序表的节点结构;2)有序表单元模块一一实现有序表的抽象数据类型;3)集合单元模块一一实现集合获得抽象数据类型;4)主程序模块:Void main (){初始化;do{接受命令;处理命令;}while (“命令” != “退出”);}流程图三、源程序# include<stdio.h>#include<string.h>#include<stdlib.h> #include<conio.h>typedef struct node{int data;struct node* next;}lnode,*linklist;Inode *init_lnode();void input(linklist l);void jiaoji(linklist A,linklist B,linklist C);void heji(linklist A,linklist B,linklist C);void output(linklist l);void main(){lnode *a,*b,*c;a=init_lnode();b=init_lnode();c=init_lnode();printf("求AB集合的交集和并集\n"); printf("请输入A集合的元素:");input(a);printf("\n请输入B集合的元素:");input(b);printf("\n 输入完成\n");printf("\n按任意键进入主菜单:”);getch();do{char menu[]={"\n\n\n——☆ 1.交集运算☆--------------------- \n\n"" ----- ☆ 2和集运算^ -------- \n\n"" ----- ☆ 3.差集运算☆------- \n\n"" ----- ☆ 0. 退出☆------------------ \n\n" };printf("%s",menu);printf("\n 请在0-3 中选择:");scanf("%d", &sel);switch(sel){case 1:printf("AB集合的交集是:");jiaoji(A,B,C);output(C);C->next=NULL;break;case 2:printf("AB 的合集是:");heji(A,B,C);output(C);C->next=NULL;break;case 3:chaji(A,B,C);break;case 0:break;}}while(sel!=O);}lnode * init_lnode() {Inode *1; /********** 初始化函数/*主函数结束*/l=(lnode *)malloc(sizeof(lnode));l->next=NULL;return l;}/*************** 录入函********************/ void input(linklist l){lnode *s;int x;scanf("%d", &x);while(x!=0){s=(lnode *)malloc(sizeof(lnode));s->data=x;s->next=l->next;l->next=s;scanf("%d", &x);}}/************ ^交隹函^数********************* void jiaoji(linklist A,linklist B,linklist C)Inode *p,*q,*t; p=A->n ext; while(p!=NULL) {q=B->n ext;whiIe((q!=NULL)&&(q->data!=p->data))q=q->n ext;if((q!=NULL)&&(q->data==p->data)){t=(lnode*)malloc(sizeof(lnode));t->data=p->data;t->next=C->next;C->next=t;}p=p->n ext;}} void output(linklist l)/*********** 输出函数***************** {lnode *s;s=l->next;while(s!=NULL){printf("%5d",s->data); s=s->next;}printf("\n");/******** 并集函数************************* void heji(linklist A,linklist B,linklist C){lnode *p,*q,*t;p=A->n ext;while(p!=NULL){t=(lnode*)malloc(sizeof(lnode));t->data=p->data;t->next=C->next;C->next=t; p=p->n ext;q=B->n ext;while(q!=NULL){p=A->n ext;while((p!=NULL)&&(p->data!=q->data)) p=p->n ext;if (p==NULL){t=(lnode*)malloc(sizeof (lnode));t->data=q->data;t->next=C->next;C->next=t;}q=q->n ext;/********************* 差集函数**************** void chaji(linklist A,linklist B, linklist C) {lnode *p,*q,*s,*t;p=A->n ext;printf("A 与 B 的差集是:\n"); while(p!=NULL)while((q!=NULL)&&(p->data!=q->data)) q=q->n ext;if(q==NULL){q=B->n ext;s=(lnode*)malloc(sizeof(lnode));s->data=p->data; s->next=C->next;C->next=s;}p=p->n ext;}output(C);C->next=NULL;q=B->n ext;printf("B 与 A 的差集是:\n");while(q!=NULL){p=A->n ext;while((p!=NULL)&&(p->data!=q->data)) p=p->n ext;if(p==NULL){ t=(lnode*)malloc(sizeof(lnode));t->data=q->data;t->next=C->next;C->next=t;}q=q->n ext;}output(C);}}四、测试数据及程序运行情况下面是运行时的界面(附图):五、心得体会1、由于对集合的三种运算的算法推敲不足,在链表类型及其尾指针的设置时出现错误,导致程序低效。

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

数据结构课程设计学院:信息科学与工程学院专业:计算机科学与技术班级:学号:学生姓名:指导教师: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。

3、本程序抱含四个模块:1)节点结构单元模块——定义有序表的节点结构;2)有序表单元模块——实现有序表的抽象数据类型;3)集合单元模块——实现集合获得抽象数据类型;4)主程序模块:Void main(){初始化;do{接受命令;处理命令;}while(“命令”!=“退出”);}三、算法设计#include<stdio.h>#include<stdlib.h>typedef struct LNode//定义结构体类型指针{char data;struct LNode*next;}*pointer;void readdata(pointer head)//定义输入集合函数{pointer p;char tmp;scanf("%c",&tmp);while(tmp!='\n'){p=(pointer)malloc(sizeof(struct LNode));p->data=tmp;p->next=head->next;head->next=p;scanf("%c",&tmp);}}void pop(pointer head)//定义输出集合函数{pointer p;p=head->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}void and(pointer head1,pointer head2,pointer head3)//定义集合的并集函数{pointer p1,p2,p3;p1=head1->next;while(p1!=NULL){p3=(pointer)malloc(sizeof(struct LNode));p3->data=p1->data;p3->next=head3->next;head3->next=p3;p1=p1->next;}p2=head2->next;while(p2!=NULL){p1=head1->next;while((p1!=NULL)&&(p1->data!=p2->data))p1=p1->next;if (p1==NULL){p3=(pointer)malloc(sizeof(struct LNode));p3->data=p2->data;p3->next=head3->next;head3->next=p3;}p2=p2->next;}}void or(pointer head1,pointer head2,pointer head3)//定义集合的交集函数{pointer p1,p2,p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL)&&(p2->data!=p1->data))p2=p2->next;if((p2!=NULL)&&(p2->data==p1->data)){p3=(pointer)malloc(sizeof(struct LNode));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void differ(pointer head1,pointer head2,pointer head3)//定义集合的差集函数{pointer p1,p2,p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL)&&(p2->data!=p1->data))p2=p2->next;if(p2==NULL){p3=(pointer)malloc(sizeof(struct LNode));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void main()//主函数{int x;printf("(输入数据,按回车键结束,第一个集合大于第二个集合)\n");pointer head1,head2,head3;head1=(pointer)malloc(sizeof(struct LNode));head1->next=NULL;head2=(pointer)malloc(sizeof(struct LNode));head2->next=NULL;head3=(pointer)malloc(sizeof(struct LNode));head3->next=NULL;printf("请输入集合1:\n");readdata(head1);//调用输入集合函数printf("请输入集合2:\n");readdata(head2);//调用输入集合函数A:printf("1.并集 2.交集 3.差集 4.结束x.重新运算\n");do{printf("请选择序号\n");scanf("%d",&x);switch(x){case 1:printf("两集合的并是\n");and(head1,head2,head3);//调用并集函数pop(head3);head3->next=NULL;break;case 2:printf("两集合的交是\n");or(head1,head2,head3);//调用交集函数pop(head3);head3->next=NULL;break;case 3:printf("两集合的差是\n");differ(head1,head2,head3);//调用差集函数pop(head3);head3->next=NULL;break;case 4:break;default:goto A;}}while(x!=4);}四、测试数据及程序运行情况运行时提示输入:输入集合1:asd输入集合2:asf根据提示输入运算类型:1.并集 2.交集 3.差集 4.结束x.重新运算输入1,输出”fasd”输入2,输出”as”输入3,输出”d”输入4,输出”press any key to continue”(结束)输入其他数,输出” 1.并集 2.交集 3.差集 4.结束x.重新运算”(重新选择运算类型)下面是运行时的界面(附图):五、实验过程中出现的问题及解决方法1、由于对集合的三种运算的算法推敲不足,在链表类型及其尾指针的设置时出现错误,导致程序低效。

2、刚开始时曾忽略了一些变量参数的标识”&”,使调试程序浪费时间不少。

今后应重视确定参数的变量和赋值属性的区分和标识。

3、开始时输入集合后,程序只能进行一次运算,后来加入switch语句,成功解决了这一难题。

4、该算法并不能排除重复输入相同字符的情况,也不能自动滤去非法字符(如空格、阿拉伯数字等)。

5、本程序的模块划分比较合理,且尽可能的将指针的操作封装在节点和链表的两个模块中,致使集合模块的调试比较顺利。

6、本实习作业采用数据抽象的程序设计方案,将程序化分为四个层次结构,使得设计时思路清晰,实现时调试顺利,各模块具有较好的可用性,确实得到了一次良好的程序设计训练。

相关文档
最新文档