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

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

电子与信息工程学院数据结构实验报告实验名称: 集合的运算实验类型：设计(验证、设计、创新)班级: 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。

实验报告实验课程：数据结构实验项目：实验一集合的并交差运算专业：计算机科学与技术班级：姓名：学号：指导教师：目录一、问题定义及需求分析（1）实验目的（2）实验任务（3）需求分析二、概要设计：(1)抽象数据类型定义(2)主程序流程(3) 模块关系三、详细设计(1)数据类型及存储结构(2)模块设计四、调试分析(1)调试分析(2)算法时空分析(3)经验体会五、使用说明(1)程序使用说明六、测试结果(1)运行测试结果截图七、附录(1)源代码一、问题定义及需求分析（1）实验目的设计一个能演示集合的并、交、差运算程序。

（2）实验任务1)采用顺序表或链表等数据结构。

2)集合的元素限定为数字和小写英文字母。

（3）需求分析：输入形式为:外部输入字符串；输入值限定范围为:数字和小写英文字母；输出形式为：字符集；程序功能:计算两个集合的交、并、差以及重新输入集合功能；二、概要设计：(1)抽象数据类型定义：线性表(2)主程序流程：调用主菜单函数初始化两个线性表作为集合给两个集合输入数据输出集合数据元素信息另初始化两个线性表创建选择功能菜单界面通过不同选项调用不同功能函数在每个功能函数里面加结束选择功能，实现循环调用功能菜单计算完毕退出程序；（3）模块关系：差运算并运算交运算新建集合结束/返回结束三、详细设计抽象数据类型定义：typedef struct{ElemType *elem;int length;int listsize;}SqList;存储结构：顺序表；模块1-在顺序表的逻辑为i的位置插入新元素e的函数；算法如下：/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1) return 0; //i的合法值为(1 <= i <= L.length_Sq(L) + 1)if(L.length >= L.listsize){ //当前储存空间已满，增加分配newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT) * sizeof(ElemType));if(!newbase) exit(-1); //储存分配失败L.elem = newbase; //新基址L.listsize += LISTINCREMENT; //增加储存容量}q = &(L.elem[i - 1]); //q为插入位置for(p = &(L.elem[L.length - 1]); p >= q; --p)(p + 1) = p; //插入位置及之后的元素往右移q = e; //插入e++L.length; //表长加1return 1;}模块二在顺序线性表L中查找第1个与e满足compare()的元素位序，若找到，则返回其在L中的位序，否则返回0算法如下：/**在顺序线性表L中查找第1个与e满足compare()的元素位序，若找到，则返回其在L中的位序，否则返回0**/int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){ElemType *p;int i;i = 1; //i的初值为第1个元素的位序p = L.elem; //p的初值为第1个元素的储存位置while(i <= L.length && !(* compare)(*p++,e))++i; //从表L中的第一个元素开始与e比较，直到找到L中与e相等的元素时返回该元素的位置if(i <= L.length) return i; //若i的大小小于表长，则满足条件返回ielsereturn 0; //否则，i值不满足条件，返回0}模块三集合交运算算法如下：/**求集合的交集的函数**/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表Lb中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb 中共同的元素放在Lc中}}模块四集合并运算算法如下：/**求集合的并集的函数**/void Union_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length=0; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La 的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}模块五集合的差运算算法如下：/**求集合的差集函数**/void Differ_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0;for(i = 1; i <= La.length; i++){elem = La.elem[i-1]; //把表La 中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有，则把elem放入表Lc中，否则，就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb 中第i个元素赋值给elemif(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有，则把elem放入表Lc中，否则，就不存放}}四、调试分析问题分析及解决：首先，在编写程序时没有设置线性表的初始长度，导致集合元素输入错误；然后通过#define LIST_INIT_SIZE 100和#define LISTINCREMENT 10解决；时空分析：int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))时间复杂度为O(n);Status ListInsert_Sq(SqList &L,int i,ElemType e) 时间复杂度为O(n);void Union_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Mix_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Differ_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(2*m*n);改进设想：当同时求两个以上的结合间的运算是需要先进性两个集合间的运算，然后在于另外的集合进行运算；若要同事进行多个集合的运算需要建立多个顺序表；经验体会：顺序表使用起来比较简单，但长度不可随意变化，适用于大量访问元素，而不适用于大量增添和删除元素；在内存中存储地址连续；五、使用说明第一步：点击运行按钮；第二步: 根据提示输入集合A(可以连续输入，只限输入小写字母和数字)；第三步：程序自动显示输入结果；第四步：输入集合B（同第二步）；第五步：跳出主菜单界面；第六步：根据选项输入对应运算项的数字序号；第七步：显示运算结果，并可继续进行选择运算还是退出；第八步：若继续运算则返回主菜单，否则退出；第九步：循环第六、七、八步，直至选择退出；六、测试结果输入界面：并运算结果：交运算结果：差运算结果：重新建立集合并运算：七、附录#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 100//初始表空间大小#define LISTINCREMENT 10//表长增量typedef int Status; /**Status是函数类型**/typedef char ElemType;/*ElemType类型根据实际情况而定，这里假设为char*/typedef struct{ElemType *elem; /**储存空间基地址**/int length; /**当前长度**/int listsize;/**当前分配的储存容量（以sizeof(Elemtype)为单位）**/}SqList;SqList La,Lb,Lc,Ld;/**定义全局变量**//**构造一个空的线性表L**/Status InitList_Sq(SqList &L){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(!L.elem) exit(-1); /**储存分配失败**/L.length = 0;L.listsize = LIST_INIT_SIZE;/**初始储存容量**/return 1;}/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1)return 0;if(L.length >= L.listsize)//当前储存空间已满，增加分配{newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT )*sizeof(ElemType));if(!newbase) exit(-1);//储存分配失败L.elem = newbase;L.listsize += LISTINCREMENT;//增加储存容量}q = &(L.elem[i - 1]);//q为插入位置for(p = &(L.elem[L.length - 1]); p >= q; --p)*(p + 1) = *p;//插入位置及之后的元素往右移*q = e;//插入e++L.length;return 1;}/**创建一个线性表，输入数据**/void CreateList_Sq(SqList &L){ElemType ch='\0';int inlist =0,j;while((ch) != '\n'){scanf("%c",&ch);//输入数据for(j = 0; j < L.length; j++)if(ch == L.elem[j])//判断表L中是否有与ch相等的元素 {inlist = 1; //若有，则inlist置1break; //跳出本轮循环}elseinlist =0; //否则inlist为0if(!inlist && ch != '\n')//若inlist为0且ch不为”\n” ListInsert_Sq(L,L.length+1,ch);//则将ch存入表L中 }}/*判断两元素是否相等,若相等则返回1;否则返回0*/Status Equal(ElemType a,ElemType b){if(a == b)return 1;//相等，返回1elsereturn 0;//否则，返回0}/*在顺序线性表L中查找第1个与e满足compare()的元素位序，若找到，则返回其在L中的位序，否则返回0*/int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){ElemType *p;int i;i = 1;p = L.elem;//p的初值为第1个元素的储存位置while(i <= L.length && !(* compare)(*p++,e))//循环查找表L 找出其中与e相等的元素的位置++i;if(i <= L.length)//若i小于表长return i;//则i满足条件，返回i的值elsereturn 0;//否则返回0}/*销毁线性表的函数*/Status Clear_Sq(SqList &L){ElemType elem;free(L.elem);L.elem = NULL;return 1;}/*打印顺序表函数*/void Print_Sq(SqList L){int i;for(i = 0; i < L.length; i++)printf("%2c",L.elem[i]);//通过for循环将表元素全部输出 if(L.length == 0) printf("空集");//若表长为0，则输出空表 printf("\n\t\t\t此集合中的个数 n = %d\n\n",L.length);}/*求集合的并集的函数*/void Union_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length=0; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}/*求集合的交集的函数*/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表La中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb中共同的元素放在Lc中}}/*求集合的差集函数*/void Differ_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0;for(i = 1; i <= La.length; i++){elem = La.elem[i-1]; //把表La中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem);//若有，则把elem放入表Lc中，否则，就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb中第i个元素赋值给elem if(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有，则把elem放入表Lc中，否则，就不存放}}void Index_Sq(){//主菜单函数char s;int l=1;InitList_Sq(La);//初始化表Laprintf("\n\t\t 请输入集合A:");CreateList_Sq(La);//创建表Laprintf("\t\t\t集合A为");Print_Sq(La);printf("\n\n");InitList_Sq(Lb);//初始化表Lbprintf("\t\t 请输入集合B:");CreateList_Sq(Lb);//创建表Lbprintf("\t\t\t集合B为");Print_Sq(Lb);printf("\n\n");InitList_Sq(Lc);//初始化表LcInitList_Sq(Ld);//初始化表Ldwhile(l){printf("\t\t ******* 请输入您的操作选项 1、2、3、4. ****** \n\n");printf("\t\t 1、进行集合的并运算\n");printf("\t\t 2、进行集合的交运算\n");printf("\t\t 3、进行集合的差运算\n");printf("\t\t 4、重新建立两个集合\n");printf("\t\t\t");scanf("%c",&s);switch(s){case '1' : system("cls");Union_Sq(La,Lb,Lc);//调用集合的并运算函数printf("\t\t\t集合A与集合B的并集为:");print_Sq(Lc);printf("\n");break;case '2' :system("cls");Mix_Sq(La,Lb,Lc);//调用集合的交集运算函数printf("\t\t\t集合A与集合B的交集为:");print_Sq(Lc);printf("\n");break;case '3' : system("cls");Differ_Sq(La,Lb,Lc);//调用集合的差集运算函数 printf("\t\t\t集合A与集合B的差集为:");print_Sq(Lc);printf("\n");break;case '4' :system("cls");Clear_Sq(La);//销毁表LaClear_Sq(Lb);//销毁表LbClear_Sq(Lc);//销毁表LcClear_Sq(Ld);//销毁表Ldgetchar();Index_Sq();//递归调用此函数break;default : printf("\t\t\t#\tenter data error!\n");printf("\n");}printf("\t\t 继续计算请输入1，停止计算请输入0 \n");printf("\t\t\t");scanf("%d",&l);getchar();system("cls");}printf("\n\t\t**************** 谢谢使用！*****************\n");}int main(){printf("\t\t************* 欢迎使用集合操作运算器************\n");Index_Sq();//调用主菜单函数return 0;}。

数据结构课程设计实验1 线性表及其应用1．集合的并、交和差【问题描述】编制一个能演示执行集合的并、交和差运算的程序【基本要求】1）集合的元素限定为小写字母；2）演示程序以用户和计算机的对话方式执行。

void Union(OrderedSet &T,OrderedSet S1, OrderedSet S2){//求已建成的集合Sl和S2的并集T,即:S1.head!=NULL且S2.head!=NULL if(InitList(T){pl=GetEiemPos(Sl,1);p2=GetElemPos(S2,l);while(pl&&p2){cl=Elem(pl); c2=Elem(p2);if(cl<=c2){Append(T,Copy(pl);pl=SuccNode(pl);if(cl==c2) p2=SuccNode(p2);}else{ Append(T,Copy(p2)); p2=SuccNode(p2); }while(pl){ Append( T,Copy(pl)); pl=SuccNode(pl);}while(p2){Append(T,Copy(p2)); p2=SuccNode(p2);}}}//Unionvotd Intersection(OrderedSet &T,OrderedSet S1; OrderedSet S2) {//求集合 Sl 和 S2 的交集 Tif(!InitList(T)) T.head =NULL;else{pl=GetElemPos(S1,1);p2=GetElemPos(S2,l);while(pl&&p2){c1=Elem(p1);c2=Elem(p2);if(cl<c2) pl=SuccNode(pl);else if(cl>c2) p2=SuccNode(p2);else{ //cl==c2Append(T,Copy(pl));pl=SuccNode(pl);p2=SuccNode(p2);}//else}//while}// else}//Intersectionvoid Difference(OrderedSet &T,OrderedSet S1,OrderedSet S2) {//求集合Sl和S2的差集Tif(!InitList(T)) T.head =NULL;else {pl =GetElemPos(S1,l);p2=GetElemPos(S2,1);while(pl&&p2){cl=Elem(pl);c2=Elem(p2);if(cl<c2){Append(T,Copy(pl));pl=SuccNode(pl)else if(cl>c2) p2=SuccNode(p2);else // Cl ==c2{pl =SuccNode(p1);p2=SuccNode(p2);}}//whilewhile(pl){Apend(T,Copy(pl));p =SuccNode(pl);}}//else}//Differencevoid WriteSetElem(LinkType p){//显示集合的一个元素pramtk'Jh WriteElem(Elem(p));}//WriteSetElemvotd Printset(OrderedSet T){//显示集合的全部元素p=GetElemPos(T,1);printf('[']);if(p){WriteElem(Elem(p);p=SuccNode(p);}ListTraverse(p,WriteSetElem());Prtntf(')]');}//Printset实验2 栈、队列和递归程序设计2. 迷宫问题。

一、课程题目会合的并、交和差运算二、问题描绘功能：编制一个能演示履行会合的并、交和差运算的程序。

三、基本要求1）会合的元素限制为小写字母字符【‘ a’ ..‘ z’】2）演示程序以用户和计算机的对话方式履行。

四、测试数据（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、有序表的抽象数据种类定义为：input(linklist l)初始条件： l 是以 l 为头节点的空链表。

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

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

操作结果：将以l 为头节点的链表中数据逐一输出。

2、会合的抽象数据种类定义为：heji(linklist A,linklist B,linklist C)初始条件：链表A、B、C 已存在操作结果：生成一个由 A 和 B 的并集组成的会合C。

jiaoji(linklist A,linklist B ,linklist ,C)初始条件：链表A、B、C 已存在操作结果：生成一个由 A 和 B 的交集组成的会合C。

六、模块化分本程序抱含四个模块：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;lnode *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!=0);}/* 主函数结束 */ /**********初始化函数 ***************/lnode * init_lnode(){lnode *l;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){lnode *p,*q,*t;p=A->next;while(p!=NULL){q=B->next;while((q!=NULL)&&(q->data!=p->data))q=q->next;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->next;}}/***********输出函数 *****************/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->next;while(p!=NULL){t=(lnode*)malloc(sizeof(lnode));t->data=p->data;t->next=C->next;C->next=t;p=p->next;}q=B->next;while(q!=NULL){p=A->next;while((p!=NULL)&&(p->data!=q->data))p=p->next;if (p==NULL){t=(lnode*)malloc(sizeof (lnode));t->data=q->data;t->next=C->next;C->next=t;}q=q->next;}/*********************差集函数 ****************/ void chaji(linklist A,linklist B, linklist C){lnode *p,*q,*s,*t;p=A->next;printf("A与B的差集是:\n");while(p!=NULL){q=B->next;while((q!=NULL)&&(p->data!=q->data))q=q->next;if(q==NULL){s=(lnode*)malloc(sizeof(lnode));s->data=p->data;s->next=C->next;C->next=s;}p=p->next;}output(C);C->next=NULL;q=B->next;printf("B 与 A 的差集是 :\n");while(q!=NULL){p=A->next;while((p!=NULL)&&(p->data!=q->data)) p=p->next;if(p==NULL){t=(lnode*)malloc(sizeof(lnode));t->data=q->data;t->next=C->next;C->next=t;}q=q->next;}output(C);}} 四、测试数据及程序运转状况程序运转结果 :八、心得领会1、因为对会合的三种运算的算法斟酌不足，在链表种类及其尾指针的设置时出现错误，以致程序低效。

集合交并差运算课程设计一、课程目标知识目标：1. 理解集合交、并、差运算的基本定义，掌握相关的数学符号和术语；2. 能够运用集合交、并、差运算解决实际问题，形成数学模型；3. 了解集合运算在现实生活中的应用，理解其与日常生活和各学科之间的联系。

技能目标：1. 能够准确地使用集合交、并、差运算进行数学表达和计算；2. 培养学生的逻辑思维和抽象思维能力，提高解决问题的策略和方法；3. 学会运用集合运算辅助解题，提高解题效率。

情感态度价值观目标：1. 激发学生对数学学习的兴趣，培养良好的学习态度和习惯；2. 培养学生的团队合作意识，提高沟通与协作能力；3. 培养学生勇于探索、积极思考的精神，树立正确的价值观。

本课程针对的是初中年级学生，他们在之前的学习中已经接触过基本的集合概念。

通过对集合交、并、差运算的学习，旨在使学生在掌握基本概念的基础上，提高运用集合运算解决问题的能力，培养他们的逻辑思维和抽象思维能力。

在教学过程中，要注意结合学生的实际情况，设计有趣味性和挑战性的教学活动，使学生在轻松愉快的氛围中学习，达到预期的学习成果。

同时，注重培养学生的情感态度和价值观，使他们形成积极向上的人生态度。

二、教学内容1. 集合的基本概念复习：回顾集合的定义、元素的特征、集合的表示方法等；- 教材章节：第一章 集合与函数概念2. 集合交、并、差运算的定义及性质：- 交集的定义与性质- 并集的定义与性质- 差集的定义与性质- 教材章节：第二章 集合的运算3. 集合运算在实际问题中的应用：- 示例题目的解析与练习- 生活实例的引入与解决- 教材章节：第二章 集合的运算4. 集合运算的综合运用：- 混合运算的解题步骤与技巧- 解题策略的培养与训练- 教材章节：第二章 集合的运算教学内容按照由浅入深的原则进行安排，先复习集合的基本概念，再引入交、并、差运算的定义和性质，接着通过实际问题的应用巩固所学知识，最后进行集合运算的综合运用。

集合的并交差运算数据结构课程设计#include&lt;string.h&gt;#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#include&lt;stdlib.h&gt;#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define INFEASIBLE -1#define OVERFLOW -2#define NULL 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef char ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList &amp;l){l.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!l.elem) exit(OVERFLOW);l.length=0;l.listsize=LIST_INIT_SIZE;return OK;}int ListLength(SqList l){return(l.length);}Status ListInsert_Sq(SqList &amp;L,int i, ElemType e){//在顺序表L的第i个位置前插入元素e,i的合法值为1..L.length+1 if(i&lt;1||i&gt;L.length+1)return ERROR;if(L.length&gt;=L.listsize){ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}ElemType *q=&amp;L.elem[i-1], *p=&amp;L.elem[L.length-1];while(p&gt;=q){*(p+1)=*p; --p;} //插入位置后的元素右移*q=e;++L.length;return OK;}Status CreatSqList(SqList &amp;l,ElemType a[],int n){int len=ListLength(l);for(int i=0;i&lt;n;i++){if(a[i]&gt;=&#39;a&#39;&amp;&amp;a[i]&lt;=&#39;z&#39;) ListInsert_Sq(l,++len,a[i]);}return OK;}Status GetElem(SqList L,int i,ElemType &amp;e){if(i&lt;=0||i&gt;L.length)return ERROR;elsee=*(L.elem+i-1);return OK;}Status equal(ElemType e1,ElemType e2){if(e1==e2)return TRUE;elsereturn FALSE;}int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType,ElemType)){ElemType *p=L.elem; //p指向第一个元素int i=1; //i始终为p所指向元素的位序while(i&lt;=L.length&amp;&amp;!(*compare)(*p++,e))++i;if(i&lt;=L.length)return(i);elsereturn 0;}Status ListDelete(SqList &amp;L,int i,ElemType &amp;e) {//在顺序表Ｌ中删除第ｉ个元素，用ｅ返回其值．if(i&lt;1||i&gt;L.length)return ERROR;//删除位置不合理ElemType *p=&amp;L.elem[i-1],*q=L.elem+L.length-1; e=*p;while(p&lt;q){*p=*(p+1); ++p;} //删除位置后的元素左移--L.length;return OK;}void Union(SqList &amp;La,SqList Lb){//将所有在线性表Lb中而不在La中的元素插入Laint la_len , lb_len;ElemType e;la_len=ListLength(La);lb_len=ListLength(Lb);for(int i=1;i&lt;=lb_len;++i){GetElem(Lb,i,e);if(LocateElem_Sq(La,e,equal)==0)ListInsert_Sq(La,++la_len,e);}}Status JiaoJi(SqList l1,SqList l2, SqList &amp;l3) {int l1_len, l2_len,l3_len,i=1,j=1;ElemType e,u;l1_len=ListLength(l1);l2_len=ListLength(l2);l3_len=ListLength(l3);for(i=1;i&lt;=l1_len;i++){GetElem(l1,i,e);for(j=l2_len;j&gt;=1;j--){GetElem(l2,j,u);if(e==u){ListInsert_Sq(l3,++l3_len,u);break;}elsecontinue;}}return OK;}Status ChaJi(SqList &amp;l1,SqList l2) {SqList lc;int count=0,lc_len,l1_len,l2_len; ElemType e,u,f;InitList(lc);JiaoJi(l1,l2,lc);lc_len=ListLength(lc);l1_len=ListLength(l1);l2_len=ListLength(l2);for(int i=1;i&lt;=lc_len;i++) {GetElem(lc,i,e);for(int j=1;j&lt;=l1_len;j++) {GetElem(l1,j,u);if(u==e){ListDelete(l1,j,f);}}}return OK;}void Outputlist(SqList &amp;L){if(0==L.length)printf(&quot;空集!&quot;);elsefor(int i=0;i&lt;L.length;++i){printf(&quot;%c&quot;,*(L.elem+i));}}void main(){system(&quot;@title 集合的并交叉运算&quot;);for(1;;){system(&quot;color a1&quot;);int c;printf(&quot;********************************************************************\n&quot;);printf(&quot; ######## 执行程序: 1 ######## 退出程序: 2\n&quot;);printf(&quot;***************************************************** ***************\n&quot;);printf(&quot;请按键选择: &quot;);scanf(&quot;%d&quot;,&amp;c);getchar();printf(&quot;\n&quot;);if(c==1){SqList l1,l2,l3,la;int n1,n2,i,j;char a1[30], a2[30];InitList(l1);InitList(l2);InitList(l3);InitList(la);printf(&quot;请输入第一个集合: &quot;);gets(a1);n1=strlen(a1);for(i=n1-1;i&gt;=0;i--) //从最后一个开始依次与前面的比较重复赋值为0{for(j=0;j&lt;i;j++){if(a1[j]==a1[i])a1[i]=0;}}CreatSqList(l1,a1,n1);la=l1;printf(&quot;请输入第二个集合: &quot;); gets(a2);n2=strlen(a2);for(i=n2-1;i&gt;=0;i--) //同上{for(j=0;j&lt;i;j++){if(a1[j]==a1[i])a1[i]=0;}}CreatSqList(l2,a2,n2);printf(&quot;集合的交集是: &quot;);JiaoJi(l1,l2,l3);Outputlist(l3);printf(&quot;\n&quot;);printf(&quot;集合的并集是: &quot;);Union(l1,l2);Outputlist(l1);printf(&quot;\n&quot;);printf(&quot;集合的差集是: &quot;);ChaJi(la,l2);Outputlist(la);printf(&quot;\n\n**********************按任意键清屏!*************************&quot;);system(&quot;pause&gt;null&quot;);system(&quot;cls&quot;);}elseexit(0);}}。

<数据结构>课程设计题目:（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++课程设计题目: 集合的并、交和差运算一、设计题目集合的并、交和差运算二、小组成员分工说明一个人三、需求分析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五、详细设计实现概要设计中定义的所有的类的定义及类中成员函数，并对主要的模块写出伪码算法。