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

合集下载

集合的交并差运算

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

数据结构实验报告--单链表

数据结构实验报告--单链表

数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式,深入了解单链表的数据结构以及相关操作,提升对数据结构的理解和应用能力。

1.2 实验内容本实验主要包括以下几个方面的内容:●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。

2.2 单链表的基本操作①单链表的插入操作在单链表中,可以通过插入操作在指定位置插入一个新节点,该操作主要包括以下步骤:●创建一个新的节点,并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中,可以通过删除操作删除指定位置的节点,该操作主要包括以下步骤:●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点,并执行相应的操作。

④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。

⑤单链表的查找操作在单链表中,可以通过查找操作找到指定值的节点。

⑥单链表的修改操作在单链表中,可以通过修改操作修改指定位置的节点的值。

3.实验过程3.1 实验环境本次实验使用C语言进行编程,需要先安装相应的编程环境,如gcc编译器。

3.2 实验步骤①单链表的创建和初始化首先创建一个空链表,并初始化链表的头指针。

②单链表的插入操作按照需求,在链表的指定位置插入一个新节点。

③单链表的删除操作按照需求,删除链表中的指定位置的节点。

④单链表的遍历操作依次访问链表中的每一个节点,并输出其值。

⑤单链表的逆置操作将单链表中的节点顺序进行逆置。

⑥单链表的查找操作按照需求,在链表中查找指定值的节点。

3.2.7 单链表的修改操作按照需求,修改链表中指定位置的节点的值。

实验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);}}。

基于单链表实现集合的并交差运算实验报告

基于单链表实现集合的并交差运算实验报告

基于单链表实现集合的并交差运算实验报告一 实验题目: 基于单链表实现集合的并交差运算二 实验要求:2.2:编写一个程序,实现顺序表的各种基本运算(1)初始化单链表h ;(2)依次采用尾插法插入a,b,c,d,e 元素;(3)输出单链表h(4)输出单链表h 的长度(5)判断单链表h 是否为空(6)输出单链表h 的第三个元素(7)输出元素在a 的位置(8)在第4个元素位置上插入f 元素(9)输出单链表h(10)删除L 的第3个元素(11)输出单链表(12)释放单链表2.2:编写一个程序,采用单链表表示集合(集合中不存在重复的元素),并将其按照递增的方式排序,构成有序单链表,并求这样的两个集合的并,交和差。

三 实验内容:3.1 线性表的抽象数据类型:ADT List{数据对象;D=}0,,...,2,1,ElemS et |{≥=∈n n i a a i i数据关系:R1=},...,2,,|,{11n i D a a a a i i i i =∈><--基本操作:InitList(&L)操作结果;构造一个空的线性表LDestroyList(&L)初始条件:线性表L已存在操作结果:销毁线性表LClearList(&L)初始条件:线性表L已存在操作结果:将L置为空表ListEmpty(L)初始条件:线性表已存在操作结果:若L为空表,则返回TRUE,否则返回FALSEListLength(L)初始条件:线性表已存在操作结果:返回L中数据元素的个数GetElem(L,i)初始条件:线性表已存在,1<=i<=ListLength(L)操作结果:用e返回L中第i个数据元素的值LocateElem(L,i,e)初始条件:线性表已存在,用循环遍历整个线性表,如果e与线性表中的元素相同;操作结果:用此时的i+1返回该元素在线性表的位序ListInsert(&L,i,e)初始条件:线性表存在,1<=i<=ListLength(L)+1;操作结果:在L中第i个位置之前插入新的数据元素,e,L的长度加1。

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

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

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

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

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

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

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

在计算机科学中,我们经常需要对集合进行操作,包括求并集、交集和差集。

在本文中,我们将介绍如何使用单链表来实现这些集合操作。

我们需要定义一个单链表的数据结构。

每个节点包含一个数据元素和一个指向下一个节点的指针。

我们可以使用类来实现这个数据结构,例如:```class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = None```接下来,我们需要实现集合的并、交和差运算。

首先是并运算,它将两个集合中的所有元素合并为一个新的集合。

我们可以使用两个指针分别遍历两个链表,将两个链表中的元素逐个比较,并将不重复的元素添加到结果链表中。

具体代码如下:```def union(l1, l2):result = LinkedList()p1 = l1.headp2 = l2.headwhile p1 is not None:result.append(p1.data)p1 = p1.nextwhile p2 is not None:if not result.contains(p2.data):result.append(p2.data)p2 = p2.nextreturn result```接下来是交运算,它将两个集合中共有的元素提取出来组成一个新的集合。

同样地,我们可以使用两个指针分别遍历两个链表,将相同的元素添加到结果链表中。

具体代码如下:```def intersection(l1, l2):result = LinkedList()p1 = l1.headwhile p1 is not None:if l2.contains(p1.data):result.append(p1.data)p1 = p1.nextreturn result```最后是差运算,它将第一个集合中不属于第二个集合的元素提取出来组成一个新的集合。

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

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

实验报告实验课程:数据结构实验项目:实验一集合的并交差运算专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(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)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。

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

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

使⽤单链表来实现集合的交并差运算数据结构使⽤单链表来实现集合的交并差运算数据结构问题描述该算法的设计,要求运⾏结果如下所⽰:集合的运算如下:原集合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.掌握单链表的基本概念和原理。

2.了解单链表在计算机科学中的应用。

3.掌握单链表的基本操作,如插入、删除、遍历等。

4.通过实验,加深对理论知识的理解,提高编程能力。

二、实验内容1.实验原理:单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据域和指针域。

其中,指针域指向下一个节点,最后一个节点的指针域指向空。

单链表的主要操作包括插入、删除、遍历等。

2.实验步骤:(1)创建一个单链表。

(2)实现插入操作,即在链表的末尾插入一个新节点。

(3)实现删除操作,即删除链表中的一个指定节点。

(4)实现遍历操作,即输出链表中所有节点的数据。

3.实验代码:下面是使用Python语言实现的单链表及其基本操作的示例代码。

class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

集合的交,并,差操作

集合的交,并,差操作

目录序言 (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.调试中遇到的问题及对问题的解决方法调试中遇到的问题中主要是内存泄露问题,指针何时分配空间何时释放空间没有搞清楚,还有随机数产生完成后不知道怎么读入到链表中,对于这些问题,我上网查阅相关的资料,来进一步的确定问题的本质,从而解决问题的每一步。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

顺序表和链式表求并集交集和差集

顺序表和链式表求并集交集和差集

顺序表和链式表求并集交集和差集/*系统总体说明:用顺序表和单链表分别实现求集合的并集、交集和差集。

完成功能的详细说明:1.将集合当成一个线性表。

2.输入并创建集合,分别以顺序表和链表作为存储结构。

3.实现两个集合的并集、交集和差集运算。

4.显示集合,查看运算结果。

5.用户界面包括以下功能:创建\交集\并集\差集\显示\退出交:从一个集合中取出一个元素,在另一个集合中查找,如果有它就是交中的元素,如果没有再从第一个集合中取出第二个元素,如此进行,知道第一个集合中的元素全部取遍得到的就是这两个元素的交。

并:并也类似,关键就是判断这个元素是否都在这两个集合中出现。

差:差更简单,就是交中判断是否是第二个集合中元素的结果想反*/#include#include#includeusing namespace std;typedef int DataType;#define MAXSIZE 10typedef struct //顺序表的定义{DataType data[MAXSIZE+MAXSIZE];int len; //顺序表的长度}seqList;void Init_seqList(seqList &L) //顺序表的初始化{cout<<"初始化成功!"<<endl;< p="">L.len=0;}void set_seqList(seqList &L) //顺序表中输入集合的元素{int len;DataType a;int i=0;cout<<"输入线性表的长度为:" <<endl;< p=""> cin>>len;cout<<"输入线性表的元素为:"<<endl;< p="">while(i<len)< p="">{if(L.len>=MAXSIZE){cout<<"输入的值超出了范围。

链表-交集,并集,差集

链表-交集,并集,差集
system("pause");
}
/*测试用例
5
1 2 4 6 7
6
2 3 4 5 6 8
*/
IntiList(head1);
IntiList(head2);
LinkList head3=Fun(head1,head2);
puts("他们的交集为:");
Show(head1);
puts("他们的并集为:");
Show(head2);
puts("他们的差集为(L2-L1):");
Show(head3);
#include <stdlib.h>
typedef int ElemType;ty来自edef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//链表的建立
void IntiList(LinkList &L)
{
int i,n;
LinkList Fun(LinkList &L1,LinkList &L2)
{
//L3为差集
LinkList L3=(LinkList)malloc(sizeof(LNode));
LinkList Pa=L1,Pb=L2,Pc,Pd=L3;
while(Pa->next && Pb->next)
{
if(Pa->next->data == Pb->next->data)// L1==L2
Pd->next=Pc; //尾查法构建差集L3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验报告 单链表基本操作

数据结构实验报告 单链表基本操作

printf("查找不到该元素!\n");
printf("---------------------------------------------\n"); return 0; } 二: 1. 编写头文件及各个函数。这里函数有 CreateList_L() 创建函数,MergeList_L() 是排序函 2. 数。MergeList_L 函数不改变存储,只改变指针。PrintList_L() 用来打印结果。 写主函数。在主函数里输入元素个数,调用函数创建链表输入各个元素值。在调用函数
五、实验结果与讨论
一:
二:
-5-
六、总结
在查找元素的函数中如果按照下面的写法则会产生如下的结果:
于是必须改成 while(p&&(p->data!=e))
-6-
原因:先判断 p 是因为如果先判断 p->data 有可能此时 p 已指向空,p->data 没有值
七、思考与提高
1.如果上面实验内容 2 中合并的表内不允许有重复的数据该如何操作? 2.如何将一个带头结点的单链表 La 分解成两个同样结构的单链表 Lb,Lc, 使得 Lb 中只含 La 表中奇数结点,Lc 中含有 La 表的偶数结点?
-3-
排序,改变指针。输出。 3. 完整代码如下: #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Linklist; Status CreateList_L(Linklist &L,int n) { Linklist p,q; int i=0; L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; p=L; printf("请输入%d 个元素:\n",n); for(i=0;i<n;i++) { q=(Linklist)malloc(sizeof(LNode)); scanf("%d",&q->data); q->next=p->next; } return OK; } void MergeList_L(Linklist &La, Linklist &Lb, Linklist &Lc) { Linklist pa, pb, pc; pa = La->next; pb = Lb->next; while (pa && pb) { if(pa->data <= pb->data) { pc->next = pa; else { pc->next = pb; Lc = pc = La; p->next=q; p=q;

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

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

实验报告题目:编制一个演示集合的并、交、和差运算的程序一、问题描述:设计一个程序,要求实现集合的并、交、和差的运算二、需求分析1.本演示程序中,集合的元素限定为数字。

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

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

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

4.测试数据(1) A={1、2、3、4、9} B={2、3、5、7、8}A∪B={9、4、3、2、1、8、7、5} A∩B={3、2} A-B={9、4、1}三、概要设计为实现上述程序功能,应以有序链表表示集合。

为此,需要两个抽象数据类型:有序表和集合1.有序表的抽象数据类型定义为:ADT OrderedList{数据对象:D={ai|ai∈CharSet,i=1,2,…,n,n>=0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,ai-1<ai,i=2,…,n}基本操作:InitList(&L)操作结果:构造一个空的有序表L。

DestroyList(&L)初始条件:有序表L已存在操作结果:销毁有序表L。

CreateList(&L,n)操作结果:构造一个含有n个元素的链表L。

ListLength(L)初始条件:链表L已经存在。

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

GetElem(L,i,&e)初始条件:链表L已经存在。

操作结果:用e返回L中第i个元素的值。

Equal(c1,c2)初始条件:链表L已经存在且不为空。

操作结果:判断链表L中两元素是否相等,若相等则返回true,否则返回false。

LocateElem(L,e,equal)初始条件:链表L已经存在,Equal是数据元素的判定函数。

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

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

西安建筑科技大学华清学院课程设计(论文)题目:院(系):专业班级:计算机姓学名:号:指导教师: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、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库,实现顺序表的基本操作。

2、对线性表表示的集合,集合数据由用户从键盘输入(数据类型为整型),建立相应的顺序表,且使得数据按从小到大的顺序存放,将两个集合的并的结果存储在一个新的线性表集合中,并输出。

【实验内容】1、根据教材定义的顺序表机构,用c语言实现顺序表结构的创建、插入、删除、查找等操作;2、利用上述顺序表操作实现如下程序:建立两个顺序表表示的集合(集合中无重复的元素),并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一.statusinsertorderlist(sqlist&va,elemtypex){}二.statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三.//将合并逆置后的结果放在c表中,并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中,元素之间的关系直接通过相邻元素的位置来表达。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
(3)LinkList Merge(LinkList Head1,LinkList Head2);
//合并两个集合
(4)int IsExist(char data,LinkList Head);
int IsExist2(char data,LinkList Head);
//集合A中的元素,B中是否存在
(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):两个集合交集
//打印集合元素
5.3 系统功能模块介绍
求两个集合的并集时,Merge(LinkListHead1,LinkList Head2)函数首先调用了InitLinkList(LinkList Head)函数,多次调用了Check(char ch,LinkList Head)函数。
求两个集合的差集时,Deprive(LinkList Head1,LinkList Head2)函数同Merge(LinkList Head1,LinkList Head2)函数一样首先也调用了InitLinkList(LinkList Head)函数,后面循环调用IsExist2(char data,LinkList Head)函数。
p=newNode;
p->next=NULL;
}
p1=p1->next;
}
while(p2!=NULL)
{
if(Check(p2->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p2->data;
p->next=newNode;
Node *p1=Head1->next;
while(p1!=NULL)
{
if(IsExist2(p1->data,Head2)==1)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p1->data;
p->next=newNode;
p=newNode;
课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。严格实施课程设计这一环节,对于学生基本程序设计素养的培养和软件工作者工作作风的训练,将起到显著的促进作用。
2.
用有序单链表表示集合,实现集合的交、并、差运算。
3.
3.1 数据需求
字符范围:小写字母a,b,...,y,z,大写字母A,B,...Y,Z,和数字0,1,...8,9;
(5)LinkList Deprive(LinkList Head1,LinkList Head2);
//两个集合的差集
(6)LinkList Insection(LinkList Head1,LinkList Head2);
//两个集合交集
(7)void PrintLinkList(LinkList Head);
p->next=newNode;
p=newNode;
p->next=NULL;
}
if(Check(p2->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p2->data;
p->next=newNode;
p=newNode;
2.求两个集合的差集时,Deprive(LinkList Head1,LinkList Head2)函数首先也调用了InitLinkList(LinkList Head)函数,后面循环调用IsExist2(char data,LinkList Head)函数。
3.求两个集合交集时,Insection(LinkList Head1,LinkList Head2)函数的思路同Deprive(LinkList Head1,LinkList Head2)函数类似,它同样也是先进行初始化,首先调用了InitLinkList(LinkList Head)函数,后面循环调用IsExist(char data,LinkList Head)函数。
数据对象:属于同一个结构体的集合。
数据关系:具有线性关系。
3.2 基本功能需求
可快速的分别求出两个字符集合的交、并、差。
3.3 非功能性需求
用户界面需求:简洁、易用、易懂、友好的用户界面。
硬件要求:装有Visual C++6.0的计算机。
可靠性需求:保证用户在正常使用本系统时,用户的操作或误操作不会产生数据的丢失。
输入数据:输入10个以内的字符进行程序测试。
1、自己输入两了任意集合。
2、用对话框的形式显示集合运算的结果。
3、优化对话框。
四、应收集的资料及主要参考文献:
由于本课程没有安排“课内上机”学时,因此,在课程设计之前必须自己已经上机练习了“线性表”的基本操作。
参考文献:
1.数据结构-C语言描述,西安电子科技大学出版社,2011.5,耿国华编著
newNode->data=p1->data;
p->next=newNode;
p=newNode;
p->next=NULL;
}
}
else
{
if(Check(p1->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE);
newNode->data=p1->data;
p->next=NULL;
}
p1=p1->next;
}
return Head;
}
5.2系统函数详细介绍
(1) void InitLinkList(LinkList Head);
//初始化集合
(2) int Check(char ch,LinkList Head);
//检查p1或p2所指向数据结点该不该加入到Head为起始的集合中
Node *p1=Head1->next;
Node *p2=Head2->next;
Node *p=Head;
while(p1!=NULL&&p2!=NULL)
{
if(p1->data==p2->data)
{
if(Check(p1->data,Head)==TRUE)
{
Node *newNode=(Node*)malloc(SIZE);
求两个集合交集时,Insection(LinkList Head1,LinkList Head2)函数的思路同Deprive(LinkList Head1,LinkList Head2)函数类似,它同样也是先进行初始化,首先调用了InitLinkList(LinkList Head)函数,后面循环调用IsExist(char data,LinkList Head)函数。
4.主函数也即main()依次调用成员函数。
4.4系统功能模块图
系统功能模块图
5.
5.1 结构体的详细定义
LinkList Merge(LinkList Head1,LinkList Head2)
{
LinkList Head=(Node*)malloc(SIZE);
Head->data='\0';Head->next=NULL;
4.集合交集
5.集合并集
6.集合差集
7.单链表输出
8.主函数
《数据结构》课程设计
—集合运算
1.
“数据结构”是计算机科学与技术专业一门十分重要的专业技术基础课,计算机科学各领域及有关的应用软件都要使用到各种数据结构。在我国,”数据结构与算法”已经作为理工科非计算机专业必修的信息技术基础课程之一。世界上许多科技人员对学习、研究数据结构和算法都非常重视,对于从事计算机科学及其应用的科技工作者来说,数据结构与算法更是必须透彻地掌握的重要基础。
Deprive(LinkList Head1,LinkList Head2)
Insection(LinkList Head1,LinkList Head2)
PrintLinkList(LinkList Head)
4.3 函数间的关系
1.求两个集合的并集时,Merge(LinkList Head1,LinkList Head2)函数首先调用了InitLinkList(LinkList Head)函数,多次调用了Check(char ch,LinkList Head)函数。
学习数据结构与算法的最终目的是解决实际的应用问题,特别是非数值计算类型的应用问题。课程设计是加强学生实践能力的一个强有力手段。课程设计所安排的题目,在难度和深度方面都大于平时的上机训练,要求同学在完成设计和编程大型作业的过程中,深化对数据结构与算法课程中基本概念、理论和方法的理解;训练综合运用所学知识处理实际问题的能力,强化面向对象的程序设计理念;使同学的程序设计与调试水平有一个明显的提高。
主函数也即main()依次调用成员函数。
5.4 具体模块设计
把各个模块用图示的方法画出流程图,注意图下方要有“图号 图名”,例如“图5-1宿舍信息的录入流程图”
6.
本软件是基于Windows的编程开发,所以,软件调试必须在Windows环境下进行。调试前须做好准备工作:
相关文档
最新文档