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

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

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.提高综合运用所学的理论知识和方法独立分析和解决问题的能力
数据结构课设报告_集合的并、交和差运算的程序

操作结果:初始化集合的函数,函数参数为引用类型。
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;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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、本实习作业采用数据抽象的程序设计方案,将程序化分为四个层次结构,使得设计时思路清晰,实现时调试顺利,各模块具有较好的可用性,确实得到了一次良好的程序设计训练。