数据结构课程设计_集合运算(完整)
数据结构课程设计_集合的并、交和差运算
数据结构课程设计学院：信息科学与工程学院专业：计算机科学与技术班级：学号：学生姓名：指导教师：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。
集合的基本运算课程设计
集合的基本运算课程设计一、课程目标知识目标：1. 让学生掌握集合的基本运算概念，包括并集、交集、差集和补集。
2. 使学生能够理解和运用集合的运算法则，正确进行集合运算。
3. 让学生理解集合运算在数学及现实生活中的应用。
技能目标：1. 培养学生运用集合运算解决问题的能力，提高逻辑思维和分析能力。
2. 培养学生运用数学语言准确描述集合运算过程，提高表达和沟通能力。
情感态度价值观目标：1. 激发学生对集合运算的兴趣，培养数学学习的积极性。
2. 培养学生合作学习、共同探讨的良好学习习惯，增强团队协作意识。
3. 使学生认识到集合运算在解决实际问题中的价值，提高对数学实用性的认识。
课程性质分析：本课程为数学学科的基础内容，是中学数学的重要组成部分。
集合的基本运算对于培养学生的逻辑思维、抽象思维和解决问题能力具有重要意义。
学生特点分析：本课程面向初中年级学生，该阶段学生具有一定的数学基础，但逻辑思维和抽象思维能力尚需提高。
学生好奇心强，喜欢探索新知识，但学习自觉性有待加强。
教学要求：1. 注重启发式教学，引导学生主动参与课堂，激发学习兴趣。
2. 结合实际例子，讲解集合运算的原理和应用，提高学生的理解能力。
3. 设计丰富的课堂练习，巩固所学知识，提高学生的运用能力。
4. 关注学生个体差异，因材施教，使每个学生都能在课程中收获成长。
二、教学内容1. 集合的基本概念复习：回顾集合的定义、元素的性质以及集合的表示方法。
2. 并集的定义与运算：介绍并集的概念，讲解如何求两个集合的并集，包括图形表示和符号表示。
3. 交集的定义与运算：阐述交集的含义，通过实例演示如何进行集合的交集运算。
4. 差集的定义与运算：解释差集的概念，举例说明如何计算两个集合的差集。
5. 补集的定义与运算：引入补集的概念，讨论在全集给定的情况下如何找到集合的补集。
6. 集合运算的性质：总结并讲解集合运算的基本性质，如交换律、结合律等。
7. 集合运算的应用：通过实际例题，展示集合运算在解决实际问题中的应用。
数据结构课程设计_集合运算(完整).
电子与信息工程学院数据结构实验报告实验名称: 集合的运算实验类型：设计(验证、设计、创新)班级: 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) {a, b, c}, {b, c, d}(2) {a, b，c}, {x, y}(3) { }, {x, y}(4) {a, x, b}, {a, x, b}二、概要设计1．采用的数据结构的定义及主要功能模块的功能：在本实验中，数据的存储采用数组连续存储方式。
由于本实验相对简单，功能相对较少，只是针对数组进行交并等基础性操作，所以本实验中只采用了函数模板，这样比结构体、类以及类模板都更加简洁、易懂，也更有利于实现对多种数据类型的数据进行操作。
而且，为了满足设计的数据结构应有利于表示任意个数元素组成的集合，在本实验中采用由用户自己输入所需存储空间的最大长度，动态分配所需存储空间。
由于含有动态生成的数据成员，必须自定义析构函数以释放动态分配的内存，本实验中的析构函数为Ｄｅｌｅｔｅ（Ｔ*,T*）。
字符串的比较采用string类２、各个函数模板的声明及其功能如下：1、判断集合是否相等的运算：template<typename T>void deng_array(T*A,T*B,int A_mm,int B_mm)；//A、B为需要进行判断是否相等的数组，A_mm、B_mm 分别为数组Ａ、Ｂ的最大存储空间，由用户在输入数组数据时确定并输入，算法根据用户输入的数据动态建立相应的存储空间。
以下各形式参量的意义均与此相同。
2、集合的交运算：template<typename T>void jiao_array(T*A,T*B,int A_mm,int B_mm)；3、集合的并运算：template<typename T>void bing_array(T*A,T*B,int A_mm,int B_mm)；4、析构函数：template<typename T>void Delete(T*A,T*B)；//释放动态分配的内存5、字符串的交运算template <typename T>string jiao_string(T & A,T &B);6、字符串的并运算template <typename T>string jiao_string(T & A,T &B);7、判断字符串是否相等：采用string中的’=‘if(A==B)cout<<"EQUAL"<<endl;cout<<"NOT EQUAL"<<endl;三、详细设计1、各模块的流程图：1、判断集合是否相等的运算：2、集合的交运算：3、集合的并运算：4、析构函数：释放动态分配的内存：delete[]A;delete[]B;5、字符串的交运算6、字符串的并运算四、调试分析1、在本实验中，集合的数据类型可以实现字符型、整型，用户可根据系统提示进行选择。
集合的运算课程设计报告
集合的运算课程设计报告一、课程目标知识目标：1. 理解集合的基本概念，掌握集合的表示方法；2. 掌握集合的交集、并集、差集和对称差集的运算规则；3. 能够运用集合运算解决实际问题，如集合的包含关系、集合的等价关系等。
技能目标：1. 能够运用集合表示法准确地描述问题中的集合；2. 能够熟练地进行集合的交集、并集、差集和对称差集的运算；3. 能够运用集合运算解决实际问题，培养逻辑思维和问题解决能力。
情感态度价值观目标：1. 培养学生对集合概念的兴趣，激发学习数学的热情；2. 培养学生严谨的思考习惯，增强解决问题的自信心；3. 培养学生合作交流的意识，提高团队协作能力。
本课程针对年级特点，注重启发式教学，结合实际生活中的例子，让学生在实际问题中体会集合运算的实用性和趣味性。
通过本课程的学习，使学生掌握集合运算的基本知识，提高解决问题的能力，培养数学思维和合作精神。
教学过程中，将课程目标分解为具体的学习成果，便于后续教学设计和评估。
二、教学内容1. 集合的基本概念及表示方法- 集合的定义与性质- 集合的表示方法（列举法、描述法、图示法等）2. 集合的运算规则- 交集的定义与性质- 并集的定义与性质- 差集的定义与性质- 对称差集的定义与性质3. 集合运算的应用- 集合包含关系- 集合等价关系- 集合运算在实际问题中的应用4. 教学内容的安排与进度- 第一课时：集合的基本概念及表示方法- 第二课时：交集、并集的定义与性质- 第三课时：差集、对称差集的定义与性质- 第四课时：集合运算的应用及综合练习教学内容依据课程目标，结合教材相关章节，注重科学性和系统性。
在教学过程中，教师需引导学生通过实例理解集合的概念，掌握集合的表示方法，并学会运用集合运算规则解决实际问题。
教学内容按照教学大纲逐步展开，确保学生能够扎实掌握集合运算的相关知识。
三、教学方法本课程采用以下多样化的教学方法，以激发学生的学习兴趣和主动性：1. 讲授法：教师通过生动的语言和形象的表达，讲解集合的基本概念、表示方法以及运算规则。
数据结构课程设计_集合运算
数据结构课程设计_集合运算在计算机科学中，数据结构是组织和存储数据的方式，以便能够有效地对其进行操作和处理。
集合运算是数据结构课程中的一个重要部分，它涉及到对集合的各种操作，如并集、交集、差集等。
这些运算在许多实际应用中都有着广泛的用途，例如数据库管理、图像处理、算法设计等。
集合是由一组无序且唯一的元素组成的。
在编程中，我们可以使用不同的数据结构来实现集合，如数组、链表、哈希表等。
每种数据结构都有其特点和适用场景，选择合适的数据结构对于高效地执行集合运算至关重要。
让我们先来了解一下并集运算。
并集是指将两个集合中的所有元素合并在一起，去除重复的元素，得到一个新的集合。
例如，集合 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）理解基本数据结构的概念、原理和应用，如线性表、栈、队列、树、图等；（2）掌握常见算法的设计和分析方法，如排序、查找、递归、贪心、分治等；（3）了解数据结构在实际应用中的使用，如操作系统、数据库、编译器等。
2. 技能目标：（1）能够运用所学数据结构解决实际问题，具备良好的编程实践能力；（2）掌握算法分析方法，能够评价算法优劣，进行算法优化；（3）能够运用数据结构进行问题建模，提高问题解决效率。
3. 情感态度价值观目标：（1）激发学生对计算机科学的兴趣，培养其探索精神和创新意识；（2）培养学生团队合作意识，学会与他人共同解决问题；（3）增强学生的责任感和使命感，使其认识到数据结构在信息技术发展中的重要性。
本课程针对高中年级学生，结合学科特点和教学要求，将目标分解为具体的学习成果，为后续教学设计和评估提供依据。
课程注重理论与实践相结合，旨在提高学生的知识水平、技能素养和情感态度价值观。
二、教学内容《数据结构》教学内容依据课程目标进行选择和组织，确保科学性和系统性。
主要包括以下部分：1. 线性表：- 线性表的定义、特点和基本操作；- 顺序存储结构、链式存储结构及其应用；- 线性表的相关算法，如插入、删除、查找等。
2. 栈和队列：- 栈和队列的定义、特点及基本操作；- 栈和队列的存储结构及其应用；- 栈和队列相关算法，如进制转换、括号匹配等。
3. 树和二叉树：- 树的定义、基本术语和性质；- 二叉树的定义、性质、存储结构及遍历算法；- 线索二叉树、哈夫曼树及其应用。
4. 图：- 图的定义、基本术语和存储结构；- 图的遍历算法，如深度优先搜索、广度优先搜索；- 最短路径、最小生成树等算法。
5. 排序和查找：- 常见排序算法，如冒泡、选择、插入、快速等；- 常见查找算法，如顺序、二分、哈希等。
(完整word版)数据结构课程设计_集合的并、交和差运算(word文档良心出品)
一、课程题目会合的并、交和差运算二、问题描绘功能：编制一个能演示履行会合的并、交和差运算的程序。
三、基本要求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.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;}。
数据结构集合运算
数据结构集合运算第一点：集合的基本概念及运算集合是数学中的一种基本概念，它是由一些确定的、互不相同的对象构成的整体。
我们通常用大括号{}或者集合的符号表示集合，例如A = {1, 2, 3}。
集合中的元素是无序的，也就是说，集合中的元素顺序是不重要的。
集合的运算主要包括并集、交集、差集和补集等。
下面我们来一一介绍这些运算。
1.1 并集并集是指两个集合中所有元素的总和，用符号∪表示。
如果集合A = {1, 2, 3}和集合B = {3, 4, 5}，那么它们的并集A ∪ B就是{1, 2, 3, 4, 5}。
并集的性质包括：•交换律：A ∪ B = B ∪ A•结合律：(A ∪ B) ∪ C = A ∪ (B ∪ C)1.2 交集交集是指两个集合中共有的元素，用符号∩表示。
如果集合A = {1, 2, 3}和集合B = {3, 4, 5}，那么它们的交集A ∩ B就是{3}。
交集的性质包括：•交换律：A ∩ B = B ∩ A•结合律：(A ∩ B) ∩ C = A ∩ (B ∩ C)•空集性质：A ∩ ∅ = ∅，∅∩ A = ∅1.3 差集差集是指一个集合中不属于另一个集合的元素，用符号-表示。
如果集合A = {1, 2, 3}和集合B = {3, 4, 5}，那么它们的差集A - B就是{1, 2}。
差集的性质包括：•交换律：A - B = B - A•结合律：(A - B) - C = A - (B - C)补集是指在全集之外不属于某个集合的元素，用符号∁表示。
如果集合A = {1, 2, 3}，全集是U = {1, 2, 3, 4, 5}，那么集合A的补集∁A就是{4, 5}。
补集的性质包括：•交换律：∁A = ∁∁A•结合律：(∁A) ∪ (∁B) = ∁(A ∩ B)，(∁A) ∩ (∁B) = ∁(A ∪ B)第二点：集合运算的应用集合运算在数学中有着广泛的应用，尤其在组合数学、图论、概率论等领域中，集合运算是非常重要的工具。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
电子与信息工程学院数据结构实验报告实验名称: 集合的运算实验类型：设计(验证、设计、创新)班级: 2013级电信三班学号: ************ 姓名：陆杰实验时间：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. 链表L包括数据域和指针域，数据域中存储集合元素，指针域中存储下一个集合元素的位置；3. 创建若干个基本函数，通过函数调用对链表进行操作，实现集合的交、并、差运算。
三算法思想和程序的实现概述3.1 算法思想定义一个链表，链表有整型数据和一个指向链表的指针，程序包含定义一个新链表的函数，集合并函数，集合交函数，集合差函数。
求两集合交集并集差集从两集合的头结点开始，比较两集合元素大小，进行对应的操作，直到读取到两集合的末尾元素。
主程序先定义三个集合，创建集合A读入A数据，创建集合B读入B数据，然后输出集合A,B的元素，求出两集合并集并输出。
求两集合的交集和差集的运算与求并集的步骤类似，只需按提示输入即可。
3.2 程序的实现概述（1）输入的形式和输入值的范围：输入是从键盘输入的，输入的内容为整数。
（2）输出的形式从屏幕输出，显示用户输入集合的元素，并显示进行运算后的值。
（3）存储结构在这次设计中开始我是采用链式存储结构，使得集合的算法定义十分简洁。
（4）算法实现定义链表，创建链表，输出链表。
利用链表的来存储集合。
利用三个函数分别实现课程要求程序实现的求并、求交和差三中运算。
现分述如下：A）并运算函数该函数采取了用新集合存储两集合并后的新集合，利用一个for循环来消除新集合中相同的元素，使其在屏幕上只显示一次。
B）交运算函数该函数用于实现集合的并运算，利用for嵌套实现两链表中数据的比较，输出两链表中相同的元素。
C）差函数该函数用于实现集合的差运算，利用链表中的数据域进行判断。
输出不同于被减集合中不存在的元素。
四程序流程图流程图：五程序的实现改程序的实现步骤是定义链表，创建链表，输出链表。
利用链表的来存储集合。
利用三个函数分别实现课程要求程序实现的求并、求交和差三中运算。
现分述如下：5.1 主函数void bangzhu(){printf("\n\t\t\t***********************************");printf("\n\t\t\t* 求集合的交并差 *");printf("\n\t\t\t*********************************\n");}void main() /* 主函数 */{struct set *p,*q,*r;int m,n,node;bangzhu();for(;;){do{printf("请输入您要选择操作的代码:\n");printf("1：求两集合的并A∪B\n");printf("2：求两集合的交A∩B\n");printf("3：求两集合的差A-B\n");printf("0：退出该程序\n");scanf("%d",&node);} while(node<0||node>3);if(node==0) exit(1);printf("\t\t\t/*请输入集合A中元素的个数：*/\n");scanf("%d",&m);createlist_p(p,m); /* 调用链表生成函数生成A链表 */printf("\t\t\t/*请输入集合B中元素的个数：*/\n");scanf("%d",&n); /* 调用链表生成函数生成B链表 */createlist_p(q,n);printf("集合A中元素为:");printlist_p(p); /* 调用集合输出函数输出集合A */printf("集合B中元素为:");printlist_p(q); /* 调用集合输出函数输出集合A */ while(node<0||node>3);switch(node){case 1: Addset( p,q,r);printf("A∪B:\n");printlist_p(r);break;case 2: Subset( p,q,r);printf("A∩B:\n");printlist_p(r);break;case 3: Intset(p,q,r); printf("A-B:\n");printlist_p(r);break;}printf("\n");}}5.2 链表的生成void createlist_p(struct set *&p,int n){int i;struct set *L;p=(struct set *)malloc(sizeof(set)); /* 申请结点p */p->next=NULL; /* 定义p的next指针为空 */for(i=n;i>0;i--){L=(struct set *)malloc(sizeof(set)); /* 申请结点L*/printf("请输入该集合中第%d个整数元素:",n-i+1);scanf("%s",&L->coef);L->next=p->next;p->next=L;}}//生成新链表用于存放两集合中的元素5.3 集合的输出void printlist_p(struct set *&p){struct set *L;int i;L=p->next;if(!L) printf("该表为空!\n");while(L!=NULL){printf("%c ",L->coef);L=L->next;i++;}printf("\n");}//打印输入的两集合中的元素5.4 并运算函数void Addset(struct set *&p,struct set *&q,struct set *&r){struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set)); /* 申请结点r */r->next=NULL; /* 定义r的next指针为空 */ k=p->next; /* k指向p的下一个结点 */for(;k;){m=(struct set *)malloc(sizeof(set)); /* 申请结点m */m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;} /* 把第一个集合中的元素放在新集合中 */k=q->next;m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;for(;k;){for(n=r->next;(k->coef!=n->coef)&&n->next;){n=n->next;} /* 与新集合中的元素比较，如果不同则链入链表中 */ if((k->coef!=n->coef)&&!(n->next)){m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;}k=k->next;} /* 对第二个集合中的元素进行分析 */} /* 求A∪B */该函数采取了用新集合存储两集合并后的新集合，利用一个for循环来消除新集合中相同的元素，是其在屏幕上只显示一次。
5.5交运算函数void Subset(struct set *&p,struct set *&q,struct set *&r){struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set)); /* 申请结点r */ r->next=NULL;n=q->next;for(;n;) /* 比较p和q链表中的元素，相同的元素存入链表r中 */{m=p->next;for(;(m->coef!=n->coef)&&m->next;){m=m->next;}if(m->coef==n->coef){k=(struct set *)malloc(sizeof(set));k->next=r->next;r->next=k;k->coef=m->coef;}n=n->next;}} /* 求A∩B */该函数用于实现集合的并运算，利用for嵌套实现两链表中数据的比较，输出两链表中相同的元素。