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

合集下载

集合的交并差运算

集合的交并差运算
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.提高综合运用所学的理论知识和方法独立分析和解决问题的能力

实验4、集合的交、并和差运算的实现

实验4、集合的交、并和差运算的实现

班级:计算机11-3班学号:姓名:曲玉昆成绩:_________实验四集合的交、并和差运算的实现1. 问题描述用有序单链表表示集合,实现集合的交、并和差运算。

2. 基本要求⑴对集合中的元素,用有序单链表进行存储;⑵实现交、并、差运算时,不另外申请存储空间;⑶充分利用单链表的有序性,算法有较好的时间性能。

3. 设计思想首先,建立两个带头结点的有序单链表表示集合A和B。

单链表的结点结构和建立算法请参见教材,需要注意的是:利用头插法建立有序单链表,实参数组应该是降序排列。

其次,根据集合的运算规则,利用单链表的有序性,设计交、并和差运算。

⑴根据集合的运算规则,集合BA 中包含所有既属于集合A又属于集合B的元素。

因此,需查找单链表A和B中的相同元素并保留在单链表A中。

算法如下:Array⑵根据集合的运算规则,集合BA 中包含所有或属于集合A或属于集合B的元素。

因此,对单链表B中的每个元素x,在单链表A中进行查找,若存在和x不相同的元素,则将该结点插入到单链表A中。

算法请参照求集合的交集自行设计。

⑶根据集合的运算规则,集合A-B中包含所有属于集合A而不属于集合B的元素。

因此,对单链表B中的每个元素x,在单链表A中进行查找,若存在和x相同的结点,则将该结点从单链表A中删除。

算法请参照求集合的交集自行设计。

template<class T>struct Node{T data;N ode<T>*next;};template <class T>class LinkList{public:L inkList(T a[],int n);//建立有n个元素的单链表~LinkList();v oid Interest(Node<T> *A, Node<T> *B);//求交集v oid Sum(Node<T> *A,Node<T> *B);/v oid Subtraction(Node<T> *A,Node<T> *B);v oid PrintList();v oid Show(int i);N ode<T> *first;};template<class T>LinkList<T>::LinkList(T a[],int n){N ode<T>*s;f irst = new Node<T>;f irst->next=NULL;f or(int i=0;i<n;i++){s = new Node<T>;s->data=a[i];s->next=first->next;first->next=s; }}template <class T>LinkList<T>::~LinkList(){N ode<T> *p,*q;p = first;//工作指针p初始化w hile(p) //释放单链表的每一个结点的存储空间{q = p;//暂存被释放结点p = p->next;//工作指针p指向被释放结点的下一个结点,使单链表不断开delete q; }}template<class T>void LinkList<T>::Interest(Node<T> *A,Node<T> *B){N ode<T> *pre,*p,*q;p re = A;p =A ->next;q = B->next;w hile(p&&q){if(p->data < q->data){pre->next = p->next;p = pre->next;}else if(p->data > q->data){q = q->next;}else{pre = p;p = p->next;q = q->next;} }}//求并集template<class T>void LinkList<T>::Sum(Node<T> *A,Node<T> *B{N ode<T> *pre,*p,*q;p re = A; p = A->next;q = B->next;w hile(p&&q){if(p->data < q->data){pre = p;p = p->next;}else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = p->next;q = q->next;}}}template<class T>void LinkList<T>::Subtraction(Node<T> *A,Node<T> *B){N ode<T> *pre,*p,*q,*pra;p re = A; pra = B; p = A->next; q = B->next;w hile(p&&q){if(p->data < q->data){pre = p;p = p->next; }else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = pre->next;q = q->next;}}}template<class T>void LinkList<T>::PrintList(){N ode<T> *p;p=first->next;//工作指针p初始化w hile(p != NULL)//遍历输出所有元素{cout<<p->data;p = p->next; }c out<<endl;}//菜单函数int meun(){i nt m;d o {c out<<"请输入对应数字(1、求交集2、求并集3、求差集4、结束运行)"<<endl;c in>>m;}while(m<1||m>4);return m;}int a[]={5,4,3,2,1},b[]={6,4,2};i nt n = 5,m = 3;L inkList<int> SL(a,n);L inkList<int> sl(b,m);L inkList<int> s(a,n);L inkList<int> S(b,m);L inkList<int> l(a,n);L inkList<int> L(b,m);static bool bl = true;template<class T>void LinkList<T>::Show(int i){s witch(i) {c ase 1:{Node<T> *p,*q;p = ;q = ;();();(p,q);();cout<<endl;cout<<"已求交集"<<endl;}break;c ase 2:{Node<T> *p,*q;p = ;q = ;();();(p,q);();();cout<<"已求并集"<<endl;}break;c ase 3:{Node<T> *p,*q;p = ;q = ;();();(p,q);();cout<<"已求差集"<<endl;}break;c ase 4:{bl = false; } break; }} void main(){w hile(bl == true){int i=meun();(i);}}。

c语言程序求集合的并集,交集,差集运算

c语言程序求集合的并集,交集,差集运算

C语言是一种广泛应用的计算机程序设计语言,它具有高效、灵活、可移植等特点,因此在计算机科学领域被广泛应用。

本篇文章将探讨在C语言中如何求集合的并集、交集和差集运算。

一、集合的概念集合是数学中重要的概念,它是由元素组成的无序的集合体。

在计算机科学中,我们常常需要对集合进行各种操作,比如求并集、交集、差集等。

二、集合的表示方法在C语言中,我们可以使用数组来表示集合。

数组是一种非常基础的数据结构,它由相同类型的元素组成的有序集合。

我们可以通过定义数组来表示一个集合,并通过遍历数组来进行各种集合运算。

三、集合的并集运算集合A和集合B的并集运算是指将A和B中的所有元素放在一起组成一个新的集合。

在C语言中,我们可以通过遍历两个数组,将它们的元素放在一个新的数组中即可实现并集运算。

下面是C语言中求两个集合的并集运算的示例代码:```#include <stdio.h>int m本人n() {int setA[] = {1, 2, 3, 4, 5};int setB[] = {3, 4, 5, 6, 7};int setSize = 5;int setUnion[10];int unionSize = 0;for (int i = 0; i < setSize; i++) {setUnion[unionSize++] = setA[i]; }for (int i = 0; i < setSize; i++) {int found = 0;for (int j = 0; j < setSize; j++) {if (setB[i] == setA[j]) {found = 1;break;}}if (!found) {setUnion[unionSize++] = setB[i];}}// 输出并集for (int i = 0; i < unionSize; i++) {printf("d ", setUnion[i]);}return 0;}```以上代码中,我们定义了两个集合setA和setB,分别表示集合A和集合B,然后通过遍历这两个数组,将它们的元素放入一个新的数组setUnion中。

数据结构求集合并集交集差集算法

数据结构求集合并集交集差集算法

数据结构求集合并集交集差集算法一、介绍数据结构中的集合是一种常见的数据类型,它是由不同元素组成的无序集合。

在实际的编程中,经常需要对集合进行一些操作,如求并集、交集和差集等。

本文将从数据结构的角度出发,探讨求集合并集、交集、差集的算法及其实现。

二、集合的表示方法 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五、总结本文从数据结构的角度出发,探讨了求集合并集、交集、差集的算法及其实现。

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

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

实验报告实验课程:数据结构实验项目:实验一集合的并交差运算专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(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.本演示程序中,集合的元素限制在小写字母‘a’-‘z’之间。

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

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

3.程序的执行命令有:1)选择操作2)任意键清屏4.数据测试(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.顺序表抽象数据类型定义ADT sqlist{数据对象:D={ai|a i∈Elemset,i=1,2,3,…n,n>=0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2, … n}基本操作:InitList(&l)操作结果:构造一个空的顺序表l。

ListLength(l)初始条件:顺序表l已存在。

操作结果:返回l中的元素个数。

ListInsert_Sq(&L, i, e)初始条件:顺序表l已存在。

操作结果:在l中第i个元素前面插入元素e。

CreatSqList(&l, a[],n)初始条件:顺序表l已存在。

操作结果:将数组a[n]每个元素赋给顺序表l。

GetElem(L, i, &e)初始条件:顺序表l已存在。

数据结构课程设计

数据结构课程设计

数据结构课程设计实验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. 迷宫问题。

并集、交集、差集

并集、交集、差集

2.3.2、使用difference()方法进行差集运算
同理,使用difference()方法进行集合B和集合A的差 集也是不同的
2.4、集合的对称差集运算方法
集合的差集运算也有两种方式:
一种是使用“^”运算符进行操作
另一种是使用symmetric_difference()方法来实现。
2.4.2、使用symmetric_difference()方法进 行对称差集运算
A = {'语文','数学','英语','政治','历史','地理’} B = {'语文','数学','英语','物理','化学','生物'}
2.1、集合的交集运算方法
我们使用集合的交集运算的时候可以采用两种方式:
“&” 一种是使用
运算符进行操作,
另一种是使用intersection()方法来实现
结论:
集合中进行交集、并集、对称差集进行运算的时候, 集合A与集合B,位置替换的时候,结果相同。
集合中进行差集运算的时候,集合A与集合B,位置替 换的时候,结果不同,为的含义:
给定两个集合A、B,把他们所有的元素合并在一起组 成的集合,叫做集合A与集合B的并集。 在Python中,进行并集运算时使用“|”符号。
Seta={1,2,3} Setb={4,5,6} Setc={1,2,3,4,5,6}
1.3、集合的差集的含义: 设A,B是两个集合,则所有属于A且不属于B的元素构 成的集合,叫做集合A与集合B的差集。 在Python中,进行差集运算时使用“-”符号

使用单链表来实现集合的交并差运算数据结构

使用单链表来实现集合的交并差运算数据结构

使⽤单链表来实现集合的交并差运算数据结构使⽤单链表来实现集合的交并差运算数据结构问题描述该算法的设计,要求运⾏结果如下所⽰:集合的运算如下:原集合A: c a e h原集合B: f h b g d a有序集合A: a c e h有序集合B: a b d f g h集合的并C: a b c d e f g h集合的交C: a h集合的差C: c e代码实现⾸先这⾥交并差的实现是基于链表中的元素已经从⼩到⼤排完序的链表。

这⾥排序使⽤的是冒泡排序。

//链表的冒泡排序算法bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;while((L->next->next)!=tail){p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}//集合的并bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}elses->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//集合的交bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}p1=p1->next;}return true;}//集合的差bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL)s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//完整的代码实现#include<bits/stdc++.h>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;bool init(LinkList &L){L=(LinkList)malloc(sizeof(LNode));if(L==NULL)return false;L->next=NULL;return true;}bool search(LinkList &L, int x){LinkList p=L->next;while(p){if(p->data==x)return false;p=p->next;}return true;}bool creat_list(LinkList &L, char a[], int n) //采⽤尾插法建⽴单链表{LinkList p=L, s;for(int i=0; i<n; i++){if(search(L, a[i])==false)continue;s=(LinkList)malloc(sizeof(LNode));if(s==NULL)return false;s->data=a[i];s->next=NULL;p->next=s;p=s;}return true;}bool display(LinkList &L){LinkList p=L->next;if(p==NULL)return false;while(p){printf("%c ", p->data);p=p->next;}printf("\n");return true;}bool clear(LinkList &L){LinkList p;while(L){p=L->next;free(L);L=p;}L=NULL;return true;}bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}else{s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}return true;}bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}/*产⽣n个[min, max]的随机数。

线性表——数据结构实验报告

线性表——数据结构实验报告

实验报告题目:编制一个演示集合的并交和差运算的程序班级:姓名:学号:完成日期:年月日一,需求分析1集合的元素限定为小写字母字符[…a‟..‟z‟]。

集合输入的形式为一个以“回车键”为标志的字符串,串中字符顺序不限,不允许出现重复字符。

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

2以对话方式执行。

3程序执行的命令包括:1)构造集合;2)将集合整理为只含小写字符;3)将集合按从小到大排列;4)选择对集合的操作;5)求交集;6)求并集;7)求差集4测试数据(1)Set1=”magzine”, Set2=”paer”,Set1∪Set2=”aegimnprz”, Set1∩Set2=”ae”, Set1-Set2=”gimnz”。

(2)Set1=”012oper4a6tin89”, Set2=”eordta”,Set1∪Set2=”adeinoprt”, Set1∩Set2=”aeort”, Set1-Set2=”inp”。

二,概要设计1基本操作Lnode *InitList(void); //初始化一个集合要求无重复数ListPrint_L(struct Lnode *head); //输出所设定的集合ListDifference(struct Lnode *a,struct Lnode *b);//作集合的差运算Lnode *ListArrange(struct Lnode *head); //使集合中只存在小写字母MergeList_L(struct Lnode *ah,struct Lnode *bh); //将两个集合合并ListSwitch(struct Lnode *La,struct Lnode *Lb); //选择对集合进行的并、交、差操作ListSame(struct Lnode *La,struct Lnode *Lb); //作集合的交集Lnode *ListSort(struct Lnode *La); //进行集合元素的排列三,详细设计1元素类型、结点类型和指针类型typedef char ElemType;typedef int Status;typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*LinkList;LinkList InitList(void){ //由p1,p2申请空间,获得数据并组成链表p1=p2=(LinkList)malloc(sizeof(LinkList));while(p1->data!='\n')p2->next=p1;p2=p1;}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;}。

数据结构课程设计方案2

数据结构课程设计方案2

数据结构课程设计方案一、数据结构课程设计要求学生必须仔细阅读《数据结构》课程设计方案,认真主动完成课程设计的要求。

有问题及时主动通过各种方式与教师联系沟通。

学生要发挥自主学习的能力,充分利用时间,安排好课程设计的时间计划,并在课程设计过程中不断检测自己的计划完成情况,及时向教师汇报。

课程设计按照教学要求需要一周(按每周5天)时间完成,每天至少要上3小时的机来调试C语言设计的程序,总共至少要上机调试程序15小时,其中要在机房调试9个小时,在课余调试至少6个小时。

二、上交相关内容要求上交的成果的内容必须由以下三个部分组成,缺一不可。

1、上交源程序:学生按照课程设计的具体要求所开发的所有源程序;2、课程设计报告:(保存在word 文档中,文件名要求按照"班级名-组名-课程设计题目"起名,如文件名为"0901-第1组-运动会分数统计".doc )。

报告的封面包括:题目,组名,三个完成人的学号、姓名、分工说明。

报告的具体内容包括:1)需求分析:在该部分中叙述课程设计题目中包含的功能要求。

2)概要设计说明程序中使用的存储结构设计说明(即写出存储结构的定义),以及每个功能部分的算法设计说明(可以是描述算法的流程图)。

3)详细设计每个题目对应的源程序(一组源程序,每个功能模块采用不同的函数实现);源程序要按照写程序的规则来编写。

要结构清晰,重点函数的重点变量,重点功能部分要加上清晰的程序注释。

4)调试分析测试数据、测试输出的结果、时间复杂度分析、每个模块设计和调试时存在问题的思考(问题是哪些?问题如何解决?)、算法的改进设想。

3、课程设计总结:(保存在word 文档中)总结可以包括:课程设计过程的收获、遇到问题、遇到问题解决问题过程的思考、程序调试能力的思考、对数据结构这门课程的思考、在课程设计过程中对《数据结构》课程的认识等内容。

三、设计和调试过程的规范化要求1、对每个题目要有需求分析1)在需求分析中,将题目中要求的功能进行叙述分析,在概要设计中设计解决此问题的数据存储结构(有些题目已经指定了数据存储的,按照指定的设计),设计或叙述解决此问题的算法,描述算法建议使用流程图;2)给出实现功能的一组或多组测试数据,程序调试后,把按照此测试数据进行测试的结果列出来;3)对有些题目提出算法改进方案,比较不同算法的优缺点;4)如果程序不能正常运行,写出实现此算法中遇到的问题和改进方法。

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

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

目录一.需求分析 (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.问题描述编制一个能演示执行集合的并、交和差运算的程序。

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

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

目录1.需求分析 11.1问题描述: 11.2基本要求: 11.3测试数据: 12.概要设计 12.1.集合的数据类型定义为: 12.2.各种函数的功能: 23.详细设计 24.编码实现 45.调试分析 65.1程序运行界面如下图: 65.2遇到的问题以及解决方法: 76.课设总结 77.参考文献 81.需求分析1.1问题描述:编制一个能演示执行集合的并、交和差运算的程序。

1.2基本要求:⑴集合的元素限定为小写字母符[′a′….′z ′],集合的大小n<27。

⑵集合输入的形式为一个以"回车符"为结束标志的字符串,串中字符顺序不限,且允许出现重复字符或非法字符,程序应能自动滤去。

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

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

1.3测试数据:(1)输入集合个数为2,分别为{a,b,e,d,f},{c,f,g,n},选择集合运算类型为求集合的交集。

(2)输入集合个数为3,分别为{a,b,c},{g,h,n,k},{k,z,a},选择运算类型为求集合的并集。

(3)输入集合个数为2,分别为{b,c,d},{c,d,f,},选择运算类型为集合的差(4)输入集合个数为2,分别为{a,b,x,&,1,3,4},{a,b,c,f,g,1,4},选择集合的运算类型为集合的并集。

2.概要设计2.1.集合的数据类型定义为:struct Set{int num;bool hash[30];}num为集合的元素个数hash为利用哈希表,用来储存集合的元素。

2.2.各种函数的功能:1.void InitSet(Set &Res)操作结果:初始化集合的函数,函数参数为引用类型。

2.Set DealSet(char *s)初始条件:指针s不为空操作结果:将字符串处理成集合,生成的集合为函数返回值。

3.void PriSet(Set s)操作结果:打印集合s。

集合的交,并,差操作

集合的交,并,差操作

目录序言 (1)中文摘要 (2)1.采用类C语言定义相关数据类型 (3)2.各模块流程图及伪码算法 (4)3.函数的调用关系图 (12)4.调试分析 (13)5.测试结果 (14)6.设计总结 (19)参考文献 (20)致谢 (21)附录(源程序) (22)序言云计算来袭,计算机技术的飞速发展,给我们的生活带来了很大的便利,特别是对于数学运算,一些以前人工计算很麻烦的甚至做不出的问题,计算机在几秒钟就可以算出来。

毫无疑问,计算机技术的应用已是不可阻挡的。

这里我们要做的是集合的简单操作,包括集合的交、并、差。

经过分析,我们使用已经为业界所公认的成熟的稳定的开发工具VC6.0,利用其提供的简单操作,首先在短时间内建立程序原形,然后,对初始原型程序需求分析,编写源程序,不断修正和改进,直到形成满足要求的可行程序。

集合的操作是数据结构中最简单的操作,对集合的学习实践可以帮助我们加深对数据结的掌握程度。

本程序是用单链表的基本操作升华到集合上的操作,来实现集合运算。

中文摘要利用单链表的插入删除操作进一步升华到求两个集合的交、并、差,笛卡尔积等运算。

在Visual C++6.0中实现程序的编译,调试,运行,利用随机数验证并输出这个程序的结果。

通过该题目的设计过程,可以进一步理解和熟练掌握课本中所学的各种数据结构的知识,加深对链表的认识,特别是对于指针、文件的应用,有了更多的认识。

学会如何把学到的知识用于解决实际问题,培养自己的动手能力。

关键词:集合;链表;指针;随机数;文件;1.采用类C语言定义相关数据类型定义单链表typedef struct ListNode{int data; //集合中元素的值struct ListNode *next;//集合的指针域}ListNode,*LinkList;//结点,结构体指针2.各模块流程图及伪码算法建立链表模块LinkList CreateSet(LinkList L) {LinkList p = L,q = NULL;//读取产生的随机数作为集合的元素 FILE *rfile;rfile = fopen("jihe.txt","rb"); if ( rfile == NULL ) { printf("open data.txt error.");return 0;Linklist p,q从文件中读取数据成功randomm()否打开文件失败把生成的随机数读取到文件中fread ()是结束}int rs = 0;int rra[20] = {0};rs = fread(rra, sizeof(int),20,rfile);for ( int j = 0 ; j < rs; j++){q = NULL;q = (LinkList)malloc(sizeof(ListNode));q->next=NULL;q->data = rra[j]; //读取元素值p->next = q;p = p->next;}//forfclose(rfile);return L;}计算集合并的函数模块//求并集LinkList Union(LinkList A,LinkList B,LinkList C) {LinkList pa, pb, pc,tail; pa = A->next; pb = B->next; tail = C; while(pa && pb) { if((pa->data) <= (pb->data)){pc = (LinkList)malloc(sizeof(ListNode)); LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data<=pb->datapc->data = pa->datapc->data = pb->data结束否否是是pc->data = pa->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pa = pa->next;}//ifelse{pc = (LinkList)malloc(sizeof(ListNode));pc->data = pb->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pb = pb->next;}//else}if(pa == NULL){pc = pb;tail->next = pc;tail = pc;}//ifelse{pc = pa;tail->next = pc;tail = pc;}//else}//whilereturn(C);}计算集合交的函数模块//求交集LinkList Intersection(LinkList A,LinkList B,LinkList L) {ListNode *pa, *pb, *pc,*tail; tail = L; pa = A->next; pb = B->next; while (pa && pb) { if (pa->data < pb->data) {pa = pa->next;LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data==pb->datapc->data = pa->data释放pa,pb结束否否是是}//ifelse if (pa->data > pb->data){pb = pb->next;}//else ifelse{pc = (LinkList)malloc(sizeof(ListNode));pc->data = pa->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pa = pa->next;pb = pb->next;}//else}//whilereturn L;}计算集合1与集合2的差 的函数模块//求差集LinkList Difference(LinkList A,LinkList B,LinkList C) {LinkList pa, pb, pc; pa = A->next; pb = B->next; pc = A;while(pa && pb) { if (pa->data != pb->data) {pc->next = pa;LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data !=pb->datapc->data = pa->data释放pa,pb结束否否是是pc = pa;pa = pa->next;}//ifelse{pa = pa->next;pb = pb->next;}//else}//whilereturn A;}3.函数的调用关系图main()menu_select()CreateSet CreateSet2 Difference Union Intersection PrintSet4.调试分析a.调试中遇到的问题及对问题的解决方法调试中遇到的问题中主要是内存泄露问题,指针何时分配空间何时释放空间没有搞清楚,还有随机数产生完成后不知道怎么读入到链表中,对于这些问题,我上网查阅相关的资料,来进一步的确定问题的本质,从而解决问题的每一步。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

集合的交并差运算数据结构哎呀,今天咱们来聊聊集合的交、并、差运算这事儿。

这可不是那种枯燥无味的数学题,而是一个很有趣的话题,就像你在朋友聚会时发现大家都喜欢同一部电影,那种惊喜和亲切感。

集合运算就像社交生活中的“人际关系处理”,你想象一下,你有一堆朋友,大家各自有各自的爱好。

有些人喜欢打篮球,有些人爱看电影,还有一些人喜欢爬山。

这个时候,如果你想知道有多少人既爱看电影又爱打篮球,那就得用“交”的运算啦。

好比说,你有一个“爱打篮球”的集合和一个“爱看电影”的集合,想找出喜欢这两样的朋友,就得把这两者的共同部分找出来。

交集就像是那块小小的重叠区域,大家在那儿愉快地聚会。

这就是集合交运算的魅力所在。

让人感觉像是突然发现了一个志同道合的伙伴,简直是太开心了!我跟你说,这可不仅仅是数学,生活中你也可以用这个来搞定很多事情。

接着说到“并”的运算,想象一下,你的朋友们都有自己的圈子,打篮球的、看电影的、爬山的,大家都喜欢自己的活动。

不过,你可不想把人分开,想把所有的朋友都聚在一起。

这个时候,就得用“并”运算了。

并集就像把所有的朋友一锅端,大家在一起热热闹闹,互相交流,共同享受那种融洽的气氛。

没错,这就是社交的真谛,让所有爱好的人都聚在一起,仿佛一场欢乐的派对。

说到“差”,你可能会想,哎,这个运算是干嘛的呢?它也挺有意思的。

假如你有一个“爱打篮球”的朋友集合,里面的每个人都热爱篮球。

但是其中,有一个小伙伴最近决定不打篮球了,改去学吉他了。

你想知道还有多少人是坚持打篮球的,那就得用“差”的运算。

简单来说,就是把那些不打篮球的人从集合中剔除出去。

这个过程就像是在精简朋友圈,留下那些最热爱篮球的朋友,简直就像从一大堆零食中挑出最爱的薯片。

多爽啊!这些运算在日常生活中真的是随处可见。

比如,工作中,你可能会有很多项目在进行,有些项目可能会重叠,有些则是完全不同的。

当你在思考如何分配资源、如何管理时间时,这些集合的运算就能给你很好的参考。

java 集合的交并差运算

java 集合的交并差运算

【概述】在Java编程中,集合是非常常用的数据结构,它们可以进行交、并、差等运算,本文将围绕这几种运算展开讨论。

【一、集合的概述】1.1 集合的定义在Java中,集合是指一组元素的容器,它可以存储不同类型的数据,并提供了丰富的方法来操作这些数据。

1.2 集合的分类在Java中,集合主要分为List、Set和Map三种类型:- List:有序集合,可以存储重复元素;- Set:无序集合,不允许存储重复元素;- Map:键值对集合,存储键值对映射关系。

【二、集合的交运算】2.1 集合的交运算定义集合的交运算是指取两个集合中共同的元素,也就是取交集。

2.2 集合的交运算实现在Java中,可以使用ret本人nAll()方法来实现集合的交运算。

例如:```javaSet<Integer> set1 = new HashSet<>();set1.add(2);set1.add(3);Set<Integer> set2 = new HashSet<>();set2.add(2);set2.add(3);set2.add(4);set1.ret本人nAll(set2);System.out.println(set1); // 输出[2, 3]```【三、集合的并运算】3.1 集合的并运算定义集合的并运算是指取两个集合的所有元素,去除重复的元素后的集合。

3.2 集合的并运算实现在Java中,可以使用addAll()方法来实现集合的并运算。

例如:```javaSet<Integer> set1 = new HashSet<>();set1.add(1);set1.add(2);Set<Integer> set2 = new HashSet<>();set2.add(2);set2.add(3);set2.add(4);set1.addAll(set2);System.out.println(set1); // 输出[1, 2, 3, 4]```【四、集合的差运算】4.1 集合的差运算定义集合的差运算是指取两个集合中不同的元素,也就是取补集。

数据结构集合运算

数据结构集合运算

数据结构集合运算数据结构是计算机科学中重要的基础知识之一,它主要研究数据元素之间的逻辑关系和运算。

集合是一种常见的数据结构,它用于表示一组互不相同的元素。

集合运算是对多个集合之间进行操作的一种技术,它包括并集、交集、差集和补集等。

并集是指将两个或多个集合中的所有元素合并为一个集合,其中不包含重复的元素。

对于两个集合A和B来说,它们的并集记作A∪B。

例如,集合A={1,2,3},集合B={3,4,5},则它们的并集为A∪B={1,2,3,4,5}。

交集是指两个或多个集合中共有的元素。

对于两个集合A和B来说,它们的交集记作A∩B。

例如,集合A={1,2,3},集合B={3,4,5},则它们的交集为A∩B={3}。

差集是指属于一个集合A但不属于另一个集合B的元素。

对于两个集合A和B来说,它们的差集记作A-B。

例如,集合A={1,2,3},集合B={3,4,5},则它们的差集为A-B={1,2}。

补集是指在全集中不属于一些给定集合的元素构成的集合。

对于一个集合A来说,它的补集记作A'或A的反集。

例如,集合A={1,2,3},全集U={1,2,3,4,5},则集合A的补集为A'={4,5}。

除了上述基本的集合运算,还有其他一些常用的集合运算,如对称差集和笛卡尔积等。

对称差集是指两个集合中所有不属于交集的元素构成的集合。

对于两个集合A和B来说,它们的对称差集记作A△B。

例如,集合A={1,2,3},集合B={3,4,5},则它们的对称差集为A△B={1,2,4,5}。

笛卡尔积是指将两个集合的每个元素依次配对组成的新集合。

对于两个集合A和B来说,它们的笛卡尔积记作A×B。

例如,集合A={1,2},集合B={3,4},则它们的笛卡尔积为A×B={(1,3),(1,4),(2,3),(2,4)}。

在集合运算中,常常需要通过数据结构来存储和操作集合。

常见的实现方式包括数组和链表等。

数据结构课程设计报告---单链表表示集合---实现交并差

数据结构课程设计报告---单链表表示集合---实现交并差

西安建筑科技大学华清学院课程设计(论文)题目:院(系):专业班级:计算机姓学名:号:指导教师:2016 年9 月8 日西安建筑科技大学华清学院课程设计(论文)任务书专业班级:学生姓名:指导教师(签名):一、课程设计(论文)题目集合运算:使用链表来表示集合,完成集合的合并,求交集等操作。

二、本次课程设计(论文)应达到的目的数据结构是实践很强的课程,课程设计是加强学生实践能力的一个强有力的手段。

课程设计要求我们完成程序设计的同时能够写出比较规范的设计报告。

严格实施课程设计这一环节,对于我们基本程序素养的培养和软件工作者工作作风的训练。

将起到显著的促进作用。

本题目要达到目的:熟练掌握链表的各种操作三、本次课程设计(论文)任务的主要内容和要求(包括原始数据、技术参数、设计要求等)输入数据:输入10个以内的字符进行程序测试。

1、自己输入两了任意集合。

2、用对话框的形式显示集合运算的结果。

3、优化对话框。

四、应收集的资料及主要参考文献:由于本课程没有安排“课内上机”学时,因此,在课程设计之前必须自己已经上机练习了“线性表”的基本操作。

参考文献:1. 数据结构-C语言描述,西安电子科技大学出版社,2011.5,耿国华编著2.数决结构与算法分析(C++版),电子工业出版社,2005.7,Clifford A.Shaffer 编著3.数据结构与算法,科学出版社,2005.08,赵文静祁飞等编著4.数据结构-C++语言描述,西安交通大学出版社,1999.01,赵文静编著5.VC++深入详解,电子工业出版社,2007.7,孙鑫,于安萍编著五、审核批准意见教研室主任(签字)设计总说明该设计主要应实现以下功能:1.利用尾差法建立单链表2.对于输入的链表进行有序排列3.删除有序链表中不符合要求的元素4.调用函数对单链表进行交,并,差运算,并输出系统主要由8 个模块组成,分别是:1. 单链表的建立2.单链表的有序排列3.删除单链表中不符合条件的元素4.集合交集5.集合并集6.集合差集7.单链表输出8.主函数1.设技种算学其的别的都过理象提的计作用3.需3.13.2可3.3用硬可误5. 概4.1数(1)(2)Check(char ch,LinkList Head):检查p1或p2所指向数据结点该不该加入到Head为起始的集合中(2)Merge(LinkList Head1,LinkList Head2):合并两个集合(4)IsExist(char data,LinkList Head);IsExist2(char data,LinkList Head):集合A中的元素,B中是否存在(5)Deprive(LinkList Head1,LinkList Head2):两个集合的差集(6)Insection(LinkList Head1,LinkList Head2):两个集合交集(7)PrintLinkList(LinkList Head):打印集合元素4.2 系统包含的函数InitLinkList(LinkList Head)Check(char ch,LinkList Head)Merge(LinkList Head1,LinkList Head2)IsExist2(char data,LinkList Head)Deprive(LinkList Head1,LinkList Head2)Insection(LinkList Head1,LinkList Head2)PrintLinkList(LinkList Head)4.3 函数间的关系1.求两个集合的并集时,Merge(LinkListHead1,LinkList Head2)函数首先调用了InitLinkList(LinkList Head)函数,多次调用了Check(char ch,LinkList Head)函数。

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

相关文档
最新文档