抽象数据类型的表示与实现(实验一)
实验1线性表的抽象数据类型的实现
二、链表（带头结点）基本操作实验 链表（带头结点） 要求：数据元素类型ElemType取字符型 取字符型char。按照动态单循环 要求：数据元素类型 取字符型 。 链表结构实现如下算法（各算法边界条件适当给出）： 链表结构实现如下算法（各算法边界条件适当给出）： 创建任意字符型有序（递增排序）单循环链表（ ① 创建任意字符型有序（递增排序）单循环链表（即链表 的字符元素随机在键盘上输入），长度限定在15之内 ），长度限定在 之内； 的字符元素随机在键盘上输入），长度限定在 之内； 打印（遍历）该链表（依次打印出表中元素值）； ② 打印（遍历）该链表（依次打印出表中元素值）； 在链表中查找第i个元素 合法返回元素值 否则， 个元素， 合法返回元素值， ③ 在链表中查找第 个元素，i合法返回元素值，否则，返回 FALSE； ； 在链表中查找与一已知字符相同的第一个结点， ④ 在链表中查找与一已知字符相同的第一个结点，有则返 回TRUE，否则，返回 ，否则，返回FALSE； ； 在链表中按照有序方式插入一已知字符元素； ⑤ 在链表中按照有序方式插入一已知字符元素； 在线性表中删除第i个结点 个结点； ⑥ 在线性表中删除第 个结点； 计算链表的长度。 ⑦ 计算链表的长度。
实验环境 计算机、 语言程序设计环境 计算机、C语言程序设计环境 实验学时 2学时，选做实验。 学时， 学时 选做实验。 实验内容 一、顺序表的基本操作实现实验 要求：数据元素类型ElemType取整型 。按照顺序存储结构 取整型int。 要求：数据元素类型 取整型 实现如下算法（各算法边界条件和返回结果适当给出）： 实现如下算法（各算法边界条件和返回结果适当给出）： 创建任意整数线性表（ ① 创建任意整数线性表（即线性表的元素值随机在键盘上 输入），长度限定在20之内 ），长度限定在 之内； 输入），长度限定在 之内； 打印（遍历）该线性表（依次打印出表中元素值）； ② 打印（遍历）该线性表（依次打印出表中元素值）； 在线性表中查找第i个元素 并返回其值； 个元素， ③ 在线性表中查找第 个元素，并返回其值； 在线性表中第i个元素之前插入一已知元素 个元素之前插入一已知元素； ④ 在线性表中第 个元素之前插入一已知元素； 在线性表中删除第i个元素 个元素； ⑤ 在线性表中删除第 个元素； 求线性表中所有元素值（整数）之和； ⑥ 求线性表中所有元素值（整数）之和；
抽象数据类型-树
数据结构实验报告题目：树的抽像数据类型实现一、实验目的对某个具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。
通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。
进而达到熟练地运用本课程中的基础知识及技术的目的。
二、实验编程环境编程环境：Visual C++。
三、实验要求利用c语言实现树的抽象数据类型的基本操作。
四、基本操作描述树的结构定义和树的一组基本操作：ADT Tree{数据对象D：D是具有相同特性的数据元素的集合。
数据关系R：若D为空集，则称为空树；若D仅含有一个数据元素，则R为空集，否则R={H}，H是如下二元关系：(1) 在D中存在唯一的称为根的数据元素root，它在关系H下无前驱；(2) 若D-{root}≠NULL，则存在D-{root}的一个划分D1,D2,D3,…,Dm(m>0)，对于任意j≠k(1≤j,k≤m)有D j∩Dk=NULL,且对任意的i(1≤i≤m)，唯一存在数据元素xi∈Di有<root,xi>∈H;(3) 对应于D-{root}的划分，H-{<root,xi>,…,<root,xm>}有唯一的一个划分H1，H2,…,Hm(m>0)，对任意j≠k(1≤j,k≤m)有Hj∩Hk=NULL，且对任意i(1≤i≤m),Hi是Di上的二元关系，(Di,{Hi})是一棵符合本定义的树，称为根root的子树。
基本操作P：InitTree(&T);操作结果：构造空树T。
DestroyTree(&T);初始条件：树T存在。
操作结果：销毁树T。
CreateTree(&T,definition);初始条件：definition给出树T的定义。
操作结果：按definition构造树T。
ClearTree(&T);初始条件：树T存在。
操作结果：将树T清为空树。
实验1_抽象数据类型的表示和实现
实验1 抽象数据类型的表示和实现
一、实验目的
1.复习巩固C语言的结构体、指针、函数、动态分配内存等知识点。
2.掌握抽象数据类型的定义、表示和实现，为后续实验打好基础。
二、实验内容
基本要求：
设计实现抽象数据类型“三元组”。
每个三元组由任意三个实数的序列构成，基本操作包括：创建一个三元组，取三元组的任意一个分量，置三元组的任意一个分量，求三元组的最大分量，求三元组的最小分量，显示三元组，销毁三元组等。
选作内容：
实现两个三元组的对应分量相加或相减，给三元组的各分量同乘一个比例因子等操作。
三、实验步骤
1、写出“三元组（Triplet）”抽象数据类型的定义，即数据对象、数据关系、基本操作
2、练习抽象数据类型的表示和实现。
方法：用指针描述“三元组”，要求：动态分配内存。
3、完成所有基本操作的C语言实现与调用，并写测试程序。
抽象类型实现-二叉树-实验报告1
一、设计任务、要求及所用软件环境或工具设计任务：选用顺序存储结构和二叉链表存储结构实现抽象数据类型二叉树的基本操作编译环境：VC++6.0二、抽象数据类型定义二叉树抽象类型定义如下ADT BinaryTree{基本对象D：D是具有相同特性的数据元素的集合。
数据关系R：若D＝φ，则R＝φ，称BinaryTree为空二叉树；若D≠φ，则R＝{H}，H是如下二元关系：(1)在D中存在惟一的称为根的数据元素root，它在关系H下无前驱；(2)若D-{root}≠φ，则存在D-{root}={D1，Dr}，且D1∩Dr＝φ；(3)若D1≠φ，则D1中存在惟一的元素x1，<root,x1>∈H,且存在D1上的关系H1⊂H；若Dr≠φ，则Dr中存在惟一的元素xr，<root,xr>∈H,且存在D1上的关系Hr⊂H；H＝{＜root，xl＞，＜root，xr＞，Hl，Hr}；(4)(Dl，{Hl})是一棵符合本定义的二叉树，称为根的左子树，(Dr，{Hr})是一棵符合本定义的二叉树，称为根的右子树。
基本操作P：InitBiTree(&T);操作结果：构造空二叉树T。
DestroyBiTree(&T);初始条件：二叉树T存在操作结果：销毁二叉树TCreateBiTree(&T, definition);初始条件：definition给出二叉树T的定义操作结果：按definition构造二叉树TClearBiTree(&T);初始条件：二叉树T存在操作结果：将二叉树T清为空树BiTreeEmpty(T);初始条件：二叉树T存在操作结果：若T为空二叉树，则返回TRUE，否则返回FALSEBiTreeDepth(T);初始条件：二叉树T存在操作结果：返回T的深度Root(T);初始条件：二叉树T存在操作结果：返回T的根Value(T,e);初始条件：二叉树T存在，e是T中某个结点操作结果：返回e的值Assign(T,&e,value);操作结果：结点e赋值为valueParent(T,e);初始条件：二叉树T存在，e是T中某个结点操作结果：若e是T的非根节点，则返回它的双亲，否则返回“空”LeftChild(T,e);初始条件：二叉树T存在，e是T中某个结点操作结果：返回e的左孩子。
实验02抽象数据类型的表示及实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验二抽象数据类型的表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、通过抽象数据类型三元组的表示和实现，了解抽象数据类型的定义方式。
2、掌握抽象数据类型的定义方式和用C语言实现的方法。
3、熟悉如何运用主函数检验各基本操作函数的正确性的具体操作。
二.实验内容1、认真阅读以下有关抽象数据类型的知识：（1）抽象数据类型的概念抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，就不影响其外部的使用。
一个含抽象数据类型的软件模块通常应包含定义、表示和实现3个部分。
抽象数据类型通常采用以下格式定义：ADT抽象数据类型名{数据对象：<数据对象的定义>数据关系：<数据关系的定义>基本操作：<基本操作的定义>} ADT抽象数据类型名（2）三元组的抽象数据类型定义及表示我们以抽象数据类型三元组为例，说明抽象数据类型是如何定义的。
三元组实际上就是一个数据对象中有3个数据元素。
三元组中元素的数据类型，可以是整型数，也可以是字符、浮点数或者更复杂的数据类型。
以下是三元组的抽象数据类型定义：ADT Triplet{数据对象：D={e1, e2, e3 | e1, e2, e3∈ElemSet (ElemSet为某个数据对象的集合)}数据关系：R1={<e1, e2>, <e2, e3>}基本操作：InitTriplet(&T, v1, v2, v3)操作结果：构造三元组T，元素e1, e2和e3分别被赋以v1, v2, v3值DestroyTriplet(&T)操作结果：三元组T被销毁Get(T, i, &e)初始条件：三元组T已存在，1≤i≤3操作结果：用e返回T的第i元的值IsAscending(T)初始条件：三元组T已存在操作结果：如果T的三个元素按升序排列，则返回1，否则返回0 IsDecending(Triplet T);初始条件: 三元组T已存在操作结果: 如果T的三个元素按降序排列，则返回1，否则返回0 Put(&T, i, e)初始条件：三元组T已存在，1≤i≤3操作结果：改变T的第i元的值为eMax(T, &e)初始条件：三元组T已存在操作结果：用e返回T的三个元素中的最大值Min(T, &e)初始条件：三元组T已存在操作结果：用e返回T的三个元素中的最小值} ADT Triplet三元组在计算机中的具体存储方式可以采用动态分配的顺序存储结构，如图所示：Triplet ElemType动态分配的顺序存储的三元组2、在计算机中实现上述三元组抽象数据类型。
抽象数据类型的表示与实现
抽象数据类型的表⽰与实现
抽象数据类型的表⽰与实现
抽象数据类型(Abstract Data Type 简称ADT)是指⼀个数学模型以及定义在此数学模型上的⼀组操作。
抽象数据类型需要通过固有数据类型(⾼级编程语⾔中已实现的数据类型)来实现。
抽象数据类型是与表⽰⽆关的数据类型，是⼀个数据模型及定义在该模型上的⼀组运算。
对⼀个抽象数据类型进⾏定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定这些函数的参数性质。
⼀旦定义了⼀个抽象数据类型及具体实现，程序设计中就可以像使⽤基本数据类型那样，⼗分⽅便地使⽤抽象数据类型。
抽象数据类型的描述包括给出抽象数据类型的名称、数据的集合、数据之间的关系和操作的集合等⽅⾯的描述。
【通俗的说：就是名字、数据集合、关系和操作的集合】
抽象数据类型描述的⼀般形式如下：
ADT抽象数据类型名称 {
数据对象：
……
数据关系：
……
操作集合：
操作名1：
……
……
操作名n：
}ADT抽象数据类型名称
总结：
抽象数据类型定义（ADT）
作⽤：抽象数据类型可以使我们更容易描述现实世界。
例：⽤线性表描述学⽣成绩表，⽤树或图描述遗传关系。
定义：⼀个数学模型以及定义在该模型上的⼀组操作。
关键：使⽤它的⼈可以只关⼼它的逻辑特征，不需要了解它的存储⽅式。
定义它的⼈同样不必要关⼼它如何存储。
例：线性表这样的抽象数据类型，其数学模型是：数据元素的集合，该集合内的元素有这样的关系：除第⼀个和最后⼀个外，每个元素有唯⼀的前趋和唯⼀的后继。
可以有这样⼀些操作：插⼊⼀个元素、删除⼀个元素等。
数据结构目录.
第一课：数据结构的基本概念和术语 第二课：抽象数据类型的表示与实现 第三课：算法及算法设计要求 第四课：算法效率的度量和存储空间需求 第五课：线性表的类型定义 第六课：线性表的顺序表示和实现 第七课：实验一 线性表的顺序存储实验 第八课：线性表的链式表示与实现
数据结构的主要内容(2)
第九课：循环链表与双向链表 第十课：栈的表示与实现 第十一课：栈的应用 第十二课：实验二 循环链表实验 第十三课：队列 第十四课：串的定义 第十五课：串的表示和实现 第十六课：串操作应用举例
数据结构的主要内容(3)
第十七课：实验三：栈的表示与实现及栈的应用 第十八课：数组的顺序表示与实现 第十九课：实验四 串的实现实验 第二十课：广义表 第二十一课：树、二叉树定义及术语 第二十二课：实验五 数组实验 第二十三课：二叉树的存储结构 第二十四课：遍历二叉树
数据结构的主要内容(4)
第二十五课：单元测验 第二十六课：图的定义与术语 第二十七课：实验六 二叉树实验 第二十八课：图的存储结构 第二十九课：静态查找表（一）顺序表的查找 第三十课：静态查找表（二）有序表的查找 第三十一课：动态查找表 第三十二课：哈希表（一）
数据结构的主要内容(5)
第三十三课：哈希表（二） 第三十四课：插入排序，快速排序 第三十五课：实验七 查找 第三十六课：选择排序，归并排序 第三十七课：实验八 排序实验 第三十八课：文件概念，顺序文件 第三十九课：索引文件 第四十课：总复习
实验1线性表的抽象数据类型的实现
实验1线性表的抽象数据类型的实现实验目的1）掌握线性表的顺序存储结构和链式存储结构；2）熟练掌握顺序表和链表基本算法的实现；3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；4）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）；5）按时提交实验报告。
实验环境计算机、C语言程序设计环境实验学时2学时，必做实验。
实验内容一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法（各算法边界条件和返回结果适当给出）：1）创建任意整数线性表（即线性表的元素值随机在键盘上输入），长度限定在25之内；2）打印（遍历）该线性表（依次打印出表中元素值）；3）在线性表中查找第i个元素，并返回其值；4）在线性表中第i个元素之前插入一已知元素；5）在线性表中删除第i个元素；6）求线性表中所有元素值（整数）之和；二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。
按照动态单循环链表结构实现如下算法（各算法边界条件适当给出）：1）创建任意字符型有序（递增排序）单循环链表（即链表的字符元素随机在键盘上输入），长度限定在15之内；2）打印（遍历）该链表（依次打印出表中元素值）；3）在链表中查找第i个元素，i合法返回元素值，否则，返回FALSE；4）在链表中查找与一已知字符相同的第一个结点，有则返回TRUE，否则，返回FALSE； 5）在链表中按照有序方式插入一已知字符元素；6）在线性表中删除第i个结点；7）计算链表的长度。
实验步骤一、顺序表的源程序#include<stdlib.h>#include<stdio.h>#include<malloc.h>int list[25];int i,n,a,sum=0,k,l;int eleminsert;/*------------------创建函数--------------*/void initlist(){printf("Please input the total of the elems:");scanf("%d",&n);if(n>25||n<1) {printf("ERROE!");return;}printf("Please input the elems:...\n");for(i=0;i<n;i++){scanf("%d",&list[i]);}return;}/*------------------打印函数--------------*/void Print(int list[],int n){int j;for(j=0;j<n;j++)printf("%d\t",list[j]);printf("\n");return;}/*------------------查找函数------------*/void Search(int list[],int n,int m){if(m<1||m>n){printf("ERROR!\n"); return ;}else printf("The elem is %d at %d place\n",list[m-1],m); return;}/*----------------插入函数------------*/void Insert(int list[],int n,int m,int elem){int j;if(m<1||m>n){printf("ERROR!\n"); return ;}for(j=n-1;j>=m-1;j--){list[j+1]=list[j];}list[m-1]=elem;n=n+1;printf("The new list are:" );Print(list,n);return;}/*---------------删除函数-----------*/void Delete(int list[],int n,int m){int q;if(m<1||m>n){printf("ERROR!\n"); return ;}for(q=m-1;q<=n;q++){list[q]=list[q+1];}printf("The new list are:");Print(list,n-1);return;}/*-------------求和函数------------*/void Sum(int list[],int n,int sum){int j;for(j=0;j<n;j++){sum=sum+list[j];}printf("The sum is :%d",sum);return;}void menu(){int j;/*------------菜单函数------------*/menulab:printf("********************** MENU ******************\n\n"); printf("Create a new int list :...................press 1\n\n"); printf("Print the whole list :....................press 2\n\n"); printf("Search by order :........................press 3\n\n"); printf("Insert the elem in the place i:...........press 4\n\n"); printf("Delete the elem by order :................press 5\n\n"); printf("Sum all elem in the list :................press 6\n\n"); printf("exit the programe :.......................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~6).....");checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/switch(j){case 1:/*创建任意整数线性表*/initlist();clrscr(); /*clear screen*/goto menulab;case 2: /*打印（遍历）该线性表*/printf("The original list is:");Print(list,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*在线性表中查找第i个元素，并返回其值*/printf("Input which LNode you want to Search(Input number):"); scanf("%d",&a);getchar();Search(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*在线性表中第i个元素之前插入一已知元素*/printf("Please input the elem's place where you want to insert"); scanf("%d",&k);printf("Input the elem which you want to insert:");scanf("%d",&eleminsert);Insert(list,n,k,eleminsert);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*在线性表中删除第i个元素*/printf("Please input the elem you want to delete:");scanf("%d",&l);n=n+1;Delete(list,n,l);n=n-1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*求线性表中所有元素值（整数）之和*/Sum(list,n,sum);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 0:/*退出程序*/printf("Press any key to continue.....");getchar();exit(0);}}void main(){void menu();menu();}二、链表（带头结点）的源程序#include<stdlib.h>#include<stdio.h>struct LNode{char elem;struct LNode* next;}*l,*p,*new;int i,a,k,n;char c,s;/*----------------创建函数-------------*/void intilist(void){l=(struct LNode *)malloc(sizeof(struct LNode));l->next=NULL;clrscr();printf("Input the total of the elems:.....");scanf("%d",&n);getchar();if(n>15)printf("Error!");for(i=n;i>0;i--){new=(struct LNode *)malloc(sizeof(struct LNode));new->next=l->next;l->next=new;}p=l;while(p->next!=NULL) p=p->next;p->next=l;printf("Input elems:.......\n");p=l->next;for(i=1;i<=n;i++){scanf("%c",&p->elem);getchar();p=p->next;}return;}/*----------------排序函数-------------*/ void Sequence(struct LNode * l, int n) {int i;char swap,*e,*f;for(i=1;i<=n-1;i++){ p=l->next;while(p->next!=l){if(p->elem>p->next->elem) {e=&p->elem;f=&p->next->elem;swap=*e;*e=*f;*f=swap;} p=p->next;}}return;}/*----------------打印函数-------------*/void Print(struct LNode * l, int n){int i;p=l->next;for(i=1;i<=n;i++){printf("%c\t",p->elem);p=p->next;}printf("\n");return;}/*----------------查找函数-------------*/ void Locate(struct LNode * l, int n,int m){int i;if(m>n) { printf("FALSE!\t");return; }else { p=l;for(i=1;i<=m;i++){p=p->next;}printf("The elem is:%c\n",p->elem);}return;}/*------已知字母匹配首结点查找函数------*/void LocateLNode(struct LNode * l, int n,char m){int i;p=l;for(i=1;i<=n;i++){p=p->next; if(p->elem==m) {printf("TRUE!\n");return;}} if(i>n) printf("FALSE!\n");return;}/*----------------插入函数-------------*/void Insert(struct LNode * l, int n,char m){new=(struct LNode *)malloc(sizeof(struct LNode));new->next=l->next;l->next=new;new->elem=m;n=n+1;Sequence(l,n);Print(l,n);return;}/*----------------删除函数-------------*/void Delete(struct LNode * l, int n,int m){int i;p=l;for(i=1;i<m;i++){p=p->next;}p->next=p->next->next;n=n-1;printf("The new list is:");Print(l,n);return;}/*----------------求表长函数-------------*/void Length(int n){int i;int length=0;for(i=1;i<=n+1;i++){length=length+sizeof(struct LNode);}printf("The length of the list is:%d",length);return;}/*----------------菜单函数-------------*/void menu(){int j;menulab:printf("********************** MENU ******************\n\n"); printf("Create the new list :..................press 1\n\n"); printf("Sequence the list :...................press 2\n\n"); printf("Search the Lnode by order :............press 3\n\n"); printf("Search the Lnode by elem :.............press 4\n\n"); printf("Insert the elem :......................press 5\n\n"); printf("Delete the elem by order :.............press 6\n\n"); printf("Return the length of the list :........press 7\n\n"); printf("exit the programe :....................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~7)....."); checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/switch(j){case 1:/*创建链表并输入元素*/intilist();clrscr(); /*clear screen*/goto menulab;case 2: /*排序并打印链表*/Sequence(l,n);printf("The orignal list is:\n");Print(l,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*查找第i个元素*/printf("Input which LNode you want to locate(Input number):"); scanf("%d",&a);getchar();Locate(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*查找与已知字符相同的第一个结点*/printf("Input the elem you want to search ");scanf("%c",&c);getchar();LocateLNode(l,n,c);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*插入已知字符的结点*/printf("Input the elem you want to insert:");scanf("%c",&s);getchar();Insert(l,n,s);n=n+1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*删除第i个结点*/printf("Input which one you want to delete:");scanf("%d",&k);if(k<1||k>n)printf("ERROR!");else{Delete(l,n,k);}n=n-1;getchar();clrscr(); /*clear screen*/goto menulab;case 7:/*计算链表长度*/Length(n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case0:/*退出链表程序*/printf("Press any key to continue.....");getchar();exit(0);}}/*------------------主函数---------------*/main(){void menu(void);menu();}测试数据与实验结果（可以抓图粘贴）一、顺序表程序抓图及其简要说明菜单选项如下图1所示：该菜单由八个函数组成，实现八项功能。
抽象数据类型试验报告
抽象数据类型试验报告
实验目的：
掌握抽象数据类型的概念与实现方式，并进一步理解面向对象程序设计的思想。
实验内容：
设计并实现一个简单的学生信息管理系统，采用抽象数据类型的思想实现。
实验步骤：
1. 设计抽象数据类型：学生信息类。
学生信息类的属性包括姓名、学号、性别、年龄和班级等基本信息。
2. 编写类的定义文件，包括类名、类属性、构造函数和访问方法等。
3. 编写测试程序，实例化学生信息类并设置学生信息。
测试程序应能够对学生信息进行增、删、改、查等操作。
4. 运行测试程序，检查学生信息管理系统功能是否正常。
实验结果：
实验结果显示，学生信息管理系统可以有效地管理学生的基本信息，能够满足学校信息管理的基本需求。
抽象数据类型的应用让程序具有了更好的可维护性和可扩展性，也更符合面向对象程序设计的思想。
实验结论：
抽象数据类型是现代程序设计中的一种重要思想和技术手段，能够有效地提高程序的可重用性和可扩展性，并使程序的设计更加合理和安全。
学生信息管理系统的实现也反映了抽象数据类型的优越性，使得程序开发人员能够更加便捷和高效地开发与维护程序。
实验一ADT描述及其实现
上机实验要求及规范数据结构课程具有比较强的理论性，同时也具有较强的可应用性和实践性。
在上机实验是一个重要的教学环节。
一般情况下学生能够重视实验环节，对于编写程序上机练习具有一定的积极性。
但是容易忽略实验的总结，忽略实验报告的撰写。
对于一名大学生必须严格训练分析总结能力、书面表达能力。
需要逐步培养书写科学实验报告以及科技论文的能力。
拿到一个题目，一般不要急于编程。
按照面向过程的程序设计思路（关于面向对象的训练将在其它后继课程中进行），正确的方法是：首先理解问题，明确给定的条件和要求解决的问题，然后按照自顶向下，逐步求精，分而治之的策略，逐一地解决子问题。
具体实习步骤如下：1.问题分析与系统结构设计充分地分析和理解问题本身，弄清要求做什么（而不是怎么做），限制条件是什么。
按照以数据结构为中心的原则划分模块，搞清数据的逻辑结构（是线性表还是树、图？），确定数据的存储结构（是顺序结构还是链表结构？）。
然后设计有关操作的函数。
在每个函数模块中，要综合考虑系统功能，使系统结构清晰、合理、简单和易于调试。
最后写出每个模块的算法头和规格说明，列出模块之间的调用关系（可以用图表示），便完成了系统结构设计。
2.详细设计和编码详细设计是对函数（模块）的进一步求精，用伪高级语言（如类C语言）或自然语言写出算法框架，这时不必确定很多结构和变量。
编码，即程序设计，是对详细设计结果的进一步求精，即用某种高级语言（如C/C++语言）表达出来。
尽量多设一些注释语句，清晰易懂。
尽量临时增加一些输出语句，便于差错矫正，在程序成功后再删去它们。
3.上机准备熟悉高级语言用法，如C语言。
熟悉机器（即操作系统），基本的常用命令。
静态检查主要有两条路径，一是用一组测试数据手工执行程序（或分模块进行）；二是通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑，在这个过程中再加入一些注释和断言。
如果程序中逻辑概念清楚，后者将比前者有效。
4.上机调试程序调试最好分块进行，自底向上，即先调试底层函数，必要时可以另写一个调用驱动程序，表面上的麻烦工作可以大大降低调试时所面临的复杂性，提高工作效率。
抽象数据类型的表示与实现_数据结构（C语言版）_[共4页]
![抽象数据类型的表示与实现_数据结构（C语言版）_[共4页]](https://img.taocdn.com/s3/m/02133cf0a5e9856a57126006.png)
2．抽象数据类型抽象就是抽取出实际问题的本质。
在计算机中使用二进制数来表示数据，在汇编语言中则可给出各种数据的十进制表示，它们是二进制数据的抽象，使用者在编程时可以直接使用，不必考虑实现细节。
在高级语言中，则给出更高一级的数据抽象，出现了数据类型，如整型、实型、字符型等，可以进一步利用这些类型构造出线性表、栈、队列、树、图等复杂的抽象数据类型。
抽象数据类型（Abstract Data Type，ADT）一般指由用户定义的、表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称，具体包括三部分：数据对象，数据对象上关系的集合，以及对数据对象的基本操作的集合。
抽象数据类型的定义格式如下：ADT 抽象数据类型名 {数据对象：〈数据对象的定义〉数据关系：〈数据关系的定义〉基本操作：〈基本操作的定义〉} ADT 抽象数据类型名其中，数据对象和数据关系的定义采用数学符号和自然语言描述，基本操作的定义格式为基本操作名（参数表）初始条件：〈初始条件描述〉操作结果：〈操作结果描述〉基本操作有两种参数：赋值参数只为操作提供输入值；引用参数以“&”打头，除可提供输入值外，还将返回操作结果。
“初始条件”描述了操作执行之前数据结构和参数应满足的条件，若初始条件为空，则省略。
“操作结果”说明了操作正常完成之后，数据结构的变化状况和应返回的结果。
1.3 抽象数据类型的表示与实现运用抽象数据类型描述数据结构，有助于在设计一个软件系统时，不必首先考虑其中包含的数据对象，以及操作在不同处理器中的表示和实现细节，而是在构成软件系统的每个相对独立的模块上定义一组数据和相应的操作，把这些数据的表示和操作细节留在模块内部解决，在更高的层次上进行软件的分析和设计，从而提高软件的整体性能和利用率。
抽象数据类型的概念与面向对象方法的思想是一致的。
抽象数据类型独立于具体实现，将数据和操作封装在一起，使得用户程序只能通过抽象数据类型定义的某些操作来访问其中的数据，从而实现了信息隐藏。
抽象数据类型的表示与实现
scanf("%d",&x);
switch(x)
{
case 1:
DestroyTriplet(T);
printf("三元组已销毁，若想进行其他操作，需重启程序，新建三元组\n");
break;
case 2:
printf("请输入要查看的位置\n");
int a,e;
break;
case 4:
int f;
f=IsAscending(T);
if(f==1)
printf("是升序排列\n");
else
printf("不是升序排列\n");
break;
case 5:
int g;
g=IsDescending(T);
if(g==1)
printf("是降序排列\n");
else
scanf("%d",&a);
Get(T,a,e);
printf("第%d个值为%d\n",a,e);
break;
case 3:
printf("请输入要修改的位置和数值\n");
int b,c;
scanf("%d%d",&b,&c);
Put(T,b,c);
printf("修改后三个值为%d,%d,%d\n",T[0],T[1],T[2]);
主函数：
#include"stdio.h"
#include"1.h"
数据结构与算法实验教程实验
1.1 数据结构与算法的计算环境(实验估计时间：90分钟)1.1.1 背景知识除了进行科学计算之外，计算机已经被广泛地应用在控制、管理和数据处理等非数值计算的领域中。
与此相应，处理对象也由早先纯粹的数值发展到字符、表格和图形图像等各种具有一定结构的数据，这给计算机程序设计带来了新的问题。
为了编写一个“好”的程序，必须明确处理对象的特征及各对象之间的关系。
这就是“数据结构”这门学科形成和发展的背景。
任何实际问题只有建立了数学模型才可以被计算机计算，而数据结构就是实际问题中操作对象 (元素) 的数学抽象，算法则是建立和解决数学模型的方法。
数据结构用来反映计算机加工处理的对象，即数据的内部构成，即数据由哪几部分构成，以什么方式构成，呈什么样的结构等。
数据结构包括逻辑结构和物理结构。
这里的逻辑结构和物理结构是指一个事物的两个方面，而不是指两个不同的对象。
逻辑结构反映数据元素之间的逻辑关系，而物理结构反映了数据元素在计算机内部的存储安排，也称为存储结构。
数据结构是数据存在的形式，也是信息的一种组织方式，其目的是为了提高算法的效率。
数据结构通常与一组算法的集合相对应，通过这组算法集合可以对数据结构中的数据进行某种操作。
由于相同算法中的抽象数据类型用不同的数据结构来表示，会造成不同的执行效率，这就有必要来研究不同数据结构表示的效率差异及其适用场实验1 数据结构和算法分析基础2 数据结构与算法实验教程合。
1. 数据结构的研究对象数据结构主要研究数据的各种逻辑结构和存储结构，以及对数据的各种操作。
因此，主要有3个方面的内容，即数据的逻辑结构、数据的存储(物理) 结构和对数据的操作(或算法) 等。
通常，算法的设计取决于数据的逻辑结构，算法的实现取决于数据的存储结构。
2. 数据结构的形式化定义数据是指由有限的符号(比如“0”和“1”，具有其自己的结构、操作和相应的语义) 组成的元素的集合。
结构是元素之间关系的集合。
通常来说，一个数据结构DS 可以表示为一个二元组：DS=(D, S)这里，D是数据元素的集合(或者是“结点”，可能还含有“数据项”或“数据域”) ，S是定义在D (或其他集合) 上的关系的集合，S = { R | R : D×D×...} ，称之为元素的逻辑结构。
实验1 三元组抽象数据类型的表示与实现
暨南大学本科实验报告专用纸课程名称数据结构成绩评定实验项目名称抽像数据类型指导教师刘波实验项目编号8060154901 实验项目类型实践性实验地点南海楼212学生姓名周扬威学号2011051540学院信息科学技术学院系计算机科学系专业软件工程实验时间2012年9月16日上午～月日上午温度℃湿度一、实验目的及要求熟悉抽象数据类型的表示和实现方法.。
二、实验主要内容三元组抽象数据类型的表示与实现（1）定义三元组抽象数据类型Triplet，说明三元组存储结构以及基本操作原型；（2）实现对三元组的构造、读取、求最大、最小值等基本操作三、实验原理（抽象数据类型的定义，自定义结构类型说明，基本操作说明，主函数与其他函数的调用关系图等）。
四、实验步骤及调研分析题目一:利用C++编程语言，定义一个Triplet类包含了三元组的三个元素，构造及最大，最小值求取的操作；五、实验结果及分析题目一输入3个·整数后再输入所想求的第几个元素后得结果，若输入的数大于或小于三元组的域就会报错但仍然可以求最大最小值六、附录（源程序）#include<iostream>using namespace std;class Triplet{int *p;bool flag;public:Triplet(int v1,int v2,int v3);void Read(int i,int &e);void Max(int &e);void Min(int &e);bool Flag();};Triplet::Triplet(int v1,int v2,int v3){p=new int[3];if(!p) flag=false;else{flag=true;*p=v1;*(p+1)=v2;*(p+2)=v3;} }void Triplet::Read(int i,int &e){if(i>=1&&i<=3){e=*(p+i-1);flag=true;}else flag=false;}void Triplet::Max(int &e) {if(*p>*(p+1)) e=*p;else e=*(p+1);if(e<*(p+2)) e=*(p+2); }void Triplet::Min(int &e) {if(*p<*(p+1)) e=*p;else e=*(p+1);if(e>*(p+2)) e=*(p+2); }bool Triplet::Flag(){return flag;}int main(){int a,b,c,e;cin>>a>>b>>c;Triplet T(a,b,c);if(T.Flag()==true){cin>>a;T.Read(a,e);if(T.Flag()==false) cout<<"error"<<endl;else cout<<"第"<<a<<"个元是"<<e<<endl;T.Max(e);cout<<"最大元是"<<e<<endl;T.Min(e);cout<<"最小元是"<<e<<endl;}return 0;}。
实习0-抽象数据类型—复数 的实现
OutComplex();
求两个复数相加之和 AddComplex();
求两个复数相减之差 SubComplex();
求两个复数相乘之积 MulComplex();
求两个复数的商
SComplex();
等等;
} ADT complex;
本实验实现使用TC2.0实现复数的描述及操作。具体实现要求：
1．从键盘分别输入2个复数，并可修改已输入的复数。
* \n");
printf(" * 6.求C1和C2的差
* \n");
printf(" * 7.求C1和C2的积
* \n");
printf(" * 8.求C1和C2的商
* \n");
printf(" * 0.结束
* \n");
printf(" *****************************
C2.image); return C; }
步骤4：上机编程与调试 #include "stdafx.h" #include "Complex0515.h" #include "user.h"
int main(int argc, char* argv[]) {
int flag,flag1; float cr,ci,vr,vi; Complex c1,c2,C; CComplex0506 c;
while(1)
{
printf("请输入您的选择（0~8）:");
scanf("%d",&flag);
\n"); \n");
抽象数据实验报告一
实验报告课程数据结构实验名称抽象数据类型第页专业_数学与应用数学___ 班级___双师1班 ______ 实验日期： 2012 年 9 月 18 日报告退发 (订正、重做)一、实验目的了解抽象数据类型的定义、表示和实现方法，加强对抽象数据类型在算法中的运用。
二、实验内容实现抽象数据类型“复数”并编写程序实现复数的加法、减法、乘法，以及求复数的实部、虚部等基本操作。
三、实验环境Vc++6.0 实验室四、实验步骤程序如下：#include<stdio.h>#include<stdlib.h>typedef struct{float real;float imag;}fushu;void getfushu(fushu& f,float a,float b);void plusfushu(fushu& plu,fushu f1, fushu f2);void minusfushu(fushu& min,fushu f1, fushu f2);void multifushu(fushu& mul,fushu f1, fushu f2);void printfushu(fushu f);void getfushu(fushu& f,float a,float b){f.real=a;f.imag=b;}void plusfushu(fushu& plu,fushu f1,fushu f2){plu.real=f1.real+f2.real;plu.imag=f1.imag+f2.imag;}void minusfushu(fushu& min,fushu f1,fushu f2){min.real=f1.real-f2.real;min.imag=f1.imag-f2.imag;}void multifushu(fushu& mul,fushu f1,fushu f2) {mul.real=(f1.real*f2.real)-(f1.imag*f2.imag); mul.imag=(f1.real*f2.imag)+(f1.imag*f2.real); }void printfushu(fushu f){if (f.real!=0)printf("%lf",f.real);if (f.imag>0){printf("+");printf("%lfi",f.imag);}else if(f.imag<0){printf("%lfi",f.imag);}}void main(){float a,b,c,d;fushu f1,f2,plu,min,mul;printf("Ç밴ʵ²¿Ð鲿µÄ˳ÐòÒÀ´ÎÊäÈëÁ¼·ö·´Êý£¹"); scanf("%f%f%f%f",&a,&b,&c,&d);getfushu(f1,a,b);getfushu(f2,c,d);printf("\nÄúÊäÈëµÄµÚÒº·ö·´ÊýÊÇ:");printfushu(f1);printf("\nÄúÊäÈëµÄµÚ¶þ·ö·´ÊýÊÇ:");printfushu(f2);plusfushu(plu,f1,f2);printf("\nÏà»Ó¼á¸ûΪ:");printfushu(plu);minusfushu(min,f1,f2);printf("\nÏà»õ¼á¸ûΪ:");printfushu(min);multifushu(mul,f1,f2);printf("\nÏà³Ë¼á¸ûΪ:");printfushu(mul);printf("\n");}五、实验结果与讨论请按实部虚部的顺序依次输入两个复数：8,9,10,12您输入的第一个复数是:8.000000+9.000000i您输入的第二个复数是:10.000000+12.000000i相加结果为:18.000000+21.000000i相减结果为:-2.000000-3.000000i相乘结果为:-28.000000+186.000000iPress any key to continue六、总结（说明实验过程中遇到的问题及解决办法；新发现或个人的收获；未解决/需进一步研讨的问题或建议新实验方法等）1.刚开始不理解题目的目的，以为是编两个程序，后来问同学才知道。
抽象数据类型的表示与实现
抽象数据类型的表⽰与实现抽象数据类型的表⽰与实现(1)预定义常扯及类型：//函数结果状态代码#define OK 1#define ERROR 0#define OVERFLOW -2//Status 是函数返回值类型，其值是函数结果状态代码。
typedef int Status;(2)数据结构的表⽰（存储结构）⽤类型定义(typedef)描述；数据元素类型约定为ElemType, 由⽤户在使⽤该数据类型时⾃⾏定义。
(3)基本操作的算法都⽤如下格式的函数来描述：函数类型函数名（函数参数表）{//算法说明语句序列}//函数名当函数返回值为函数结果状态代码时，函数定义为 Status 类型。
为了便千描述算法，除了值调⽤⽅式外，增加了C+ +语⾔引⽤调⽤的参数传递⽅式。
在形参表中，以 "&"打头的参数即为引⽤参数。
传递引⽤给函数与传递指针的效果是⼀样的，形参变化实参也发⽣变化，但引⽤使⽤起来⽐指针更加⽅便、⾼效。
(4)内存的动态分配与释放。
使⽤ new 和 delete 动态分配和释放内存空间：分配空间指针变扯=new 数据类型；释放空间 delete 指针变扯；下⾯以复数为例，给出⼀个完整的抽象数据类型的定义、表⽰和实现。
ADT Complex {数据对象：D={el, e2 I el, e2ER,R 是实数集｝数据关系： S={<el,e2>1el 是复数的实部， e2 是复数的虚部｝基本操作：Creat (&C, x, y)操作结果：构造复数C, 其实部和虚部分别被赋以参数x和y的值。
初始条件：复数C已存在。
操作结果：返回复数C的实部值。
GetReal(C)初始条件：复数C已存在。
操作结果：返回复数c的虚部值。
Add( Cl,C2)初始条件：Cl, C2 是复数。
操作结果：返回两个复数 Cl和 C2 的和。
Sub(Cl,C2)初始条件：Cl, C2 是复数。
实验1：抽象数据类型
云南大学软件学院数据结构实验报告指导教师： 2009秋季学期【实验题目】实验1. 抽象数据类型.【问题描述】用C或C++语言设计并实现一个可进行复数运算的演示程序。
【基本要求】1.由输入的实部和虚部生成一个复数2.两个复数求和3.两个复数求差4.从已知复数中分离出实部和虚部5.复数及相应运算结果以相应的表现形式显示。
【实现提示】定义复数为由两个相互之间存在次序关系的实数构成的抽象数据类型，则可以利用实数的操作来实现复数的操作。
一、【概要设计】1.抽象数据类型的功能规格说明：数据对象：a、b是实数 //R是实数集数据关系：a和b构成复数，a为复数的实部，b为复数的虚部基本操作：赋值、输出、加法、减法、乘法、除法2.主程序模块与各子程序模块间的调用关系:main调用assign，生成复数；main调用print，以“a+bi”的形式输出复数；main调用cplus，实现复数的加法运算；main调用cmilus，实现复数的减法运算；main调用cmultiply，实现复数的乘法运算；main 调用cdivide,实现复数的除法运算。
二、【详细设计】1.抽象数据类型具体实现的函数原型说明:ADT cpxNum{数据对象：R(R为实数集)数据关系：a属于R, b属于R， a和b组成复数，a为实部，b为虚部基本操作：assign(*c, i, j);//给复数赋值print(cpxNum* c);//以“a+bi”的形式输出复数cplus(const cpxNum&, const cpxNum&) ; //下列四行是四则运算的函数原型cmilus(const cpxNum&, const cpxNum& );cmultiply(const cpxNum&, const cpxNum& );cdivide(const cpxNum&, const cpxNum &);}ADT cpxNum2.关键伪码：typedef struct{double _real;double _imag;} cpxNum;double assign(cpxNum &c, double i, double j){c_real=i;c_imag=j;}double print(cpxNum c) {printf("%d+%di\n",c_real,c_imag);}cplus(const cpxNum&, const cpxNum&) ; //下列四行是四则运算的函数原型cmilus(const cpxNum&, const cpxNum& );cmultiply(const cpxNum&, const cpxNum& );cdivide(const cpxNum&, const cpxNum &);3.函数的调用关系：（在main函数中）printf("请输入c1的real和imag：");scanf("%d%d\n",&i,&j);assign(c1,i,j); //调用assign函数printf("\n c1 是:");print(c1); //调用print函数printf("请输入c0的real和imag：");scanf("%d%d\n",&i,&j);assign(c0,i,j)printf("c0 是:");print(c0);cplus(c0,c1);//加法cmilus(c0,c1);//减法cmultiply(c0,c1);//乘法cdivide(c0,c1);//除法三、【测试结果】实验的输出结果(第一个复数的实部是c1_real,虚部是c1_imag, 第二个复数的实部是四、【实验总结】1.建立了一个复数函数表达式，即a+bi，且是通过两个相互之间存在次序关系的实数构成的抽象数据类型来实现的;typedef struct{double _real;double _imag;} cpxNum;2.比如调用assign来生成复数：double assign(cpxNum &c, double i, double j){c_real=i;c_imag=j;}3.调用print来以复数的形式输出：double print(cpxNum c){ printf("%d+%di\n",c_real,c_imag);}4.且用以下的调用来实现复数的相加，相减，相乘，相除：cpxNum cplus(const cpxNum& c0, const cpxNum& c1){cpxNum &c;c_real=c0_real+c1_real;c_imag=c0_imag+c1_imag;return c; }cpxNum cmilus(const cpxNum& c0, const cpxNum& c1){cpxNum c;c_real=c0_real-c1_real;c_imag=c0_imag-c1_imag;return c;}cpxNum cmultiply(const cpxNum& c0, const cpxNum& c1){cpxNum c;c_real=c0_real*c1_real-c0_imag*c1_imag;c_imag=c0_real*c1_imag+c0_imag*c1_real;return c; }cpxNum cdivide(const cpxNum& c0, const cpxNum& c1){cpxNum c;c_real=(c0_real*c1_real+c0_imag*c1_imag)/(c0_real*c0_real+c1_real*c1_r eal);c_imag=(c0_imag*c1_real-c0_real*c1_imag)/(c0_real*c0_real+c1_real*c1_r eal);return c;}做以上的调用时，要充分运用所学的C语言知识，开始时会存在错误，但不要灰心，不要沮丧，认真并用心地完成，且将课本上的东西灵活运用。
抽象数据类型
抽象数据类型的实现——以集合为例一．实验目的对某个具体的抽象数据类型，运用课本所学知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作，通过本设计性实验，检验所学知识和能力，发现学习中存在的问题，进而达到熟练地运用本课程中的基础知识及技术的目的。
二．实验内容以集合为例设计一个抽象数据类型三．实验过程1.程序如下#include <iostream.h>#include <stdio.h>#define maxCard 16#define maxLen 64#define noErr 1#define overflow 0struct Set{int elems[maxCard];int card;};struct Set_product{char elems[maxCard*maxCard][maxLen];int card;};void EmptySet(Set *);int AddElem(Set *, int );void Print(Set *);void RmvElem(Set *,int );bool Member(Set *,int );void Copy(Set * , Set * );void Intersect(Set * , Set * , Set * );bool Equal(Set * , Set * );void Cartesian_product(Set * , Set * , Set_product *);void Print(Set_product *);void main(){Set s1,s2,s3;Set_product ss1;EmptySet(&s1);EmptySet(&s2);EmptySet(&s3);AddElem(&s1,10); AddElem(&s1,20); AddElem(&s1,30); AddElem(&s1,40);AddElem(&s2,30); AddElem(&s2,50); AddElem(&s2,10); AddElem(&s2,60);cout<<"s1 = "; Print(&s1);cout<<"s2 = "; Print(&s2);RmvElem(&s2,50);cout<<"s2 - {50} = ";Print(&s2);if (Member(&s1,20))cout<<"20 is in s1\n";Intersect(&s1, &s2, &s3);cout<<"s1 intsec s2 = ";Print(&s3);if (!Equal(&s1,&s2))cout<<"s1 /= s2 \n";elsecout<<"s1 = s2 \n";Cartesian_product(&s1, &s2, &ss1);cout<<"s1 product s2 = ";Print(&ss1);} //mainvoid EmptySet(Set *set){set->card = 0;}int AddElem(Set *set, int elem) //在集合中插入元素{for (int i=0; i<set->card; ++i)if (set->elems[i]==elem)return noErr;if (set->card<maxCard){set->elems[set->card++]=elem;return noErr;}elsereturn overflow;}void Print(Set *set){if (set->card==0)cout << "{ }\n";else{cout << "{";for (int i =0; i<set->card-1; ++i)cout << set->elems[i]<<",";if (set->card>0)cout <<set->elems[set->card-1];cout << "}\n";}}//Printvoid Print(Set_product *set) //输出笛卡尔积{if (set->card==0)cout << "{ }\n";else{cout << "{";for (int i =0; i<set->card-1; ++i)cout << set->elems[i]<<",";if (set->card>0)cout <<set->elems[set->card-1];cout << "}\n";}}void RmvElem(Set *set,int elem) //在集合中移动元素{for (int i=0; i<set->card; ++i)if (set->elems[i]==elem){for (; i<set->card-1;++i)set->elems[i]=set->elems[i+1];--set->card;}}bool Member(Set *set,int elem) //判断元素是否在集合中{for(int i=0; i<set->card; ++i)if (set->elems[i]==elem)return true;return false;}void Copy(Set * set, Set * res){for (int i =0; i<set->card; ++i)res->elems[i]=set->elems[i];res->card=set->card;}//Copybool Equal(Set * set1, Set * set2) //判断两集合是否相等{if (set1->card!=set2->card)return false;for (int i=0; i<set1->card; ++i)if (!Member(set2,set1->elems[i]))return false;return true;}void Intersect(Set * set1, Set * set2, Set * res) //求交集{res->card=0;for (int i=0;i<set1->card; ++i)for (int j=0;j<set2->card;++j)if (set1->elems[i]==set2->elems[j]){res->elems[res->card++]=set1->elems[i];break;}}void Cartesian_product(Set * set1, Set * set2, Set_product *res) //求笛卡尔积{int k=0;res->card=set1->card*set2->card;for (int i=0 ;i<set1->card; ++i)for (int j=0;j<set2->card;++j,++k)sprintf ( res->elems[k], "(%d,%d)", set1->elems[i], set2->elems[j]);}2.运行结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一抽象数据类型的表示与实现一．实验目的及要求（1）熟悉类C语言的描述方法，学会将类C语言描述的算法转换为C源程序实现；（2）理解抽象数据类型的定义，编写完整的程序实现一个抽象数据类型（如三元组）；（3）认真阅读和掌握本实验的参考程序，上机运行程序，保存和打印出程序的运行结果，并结合程序进行分析。
二．实验内容（1）编程实现对一组从键盘输入的数据，计算它们的最大值、最小值等，并输出。
要求：将计算过程写成一个函数，并采用引用参数实现值的求解。
（2）编程实现抽象数据类型三元组的定义、存储和基本操作，并设计一个主菜单完成各个功能的调用。
三．实验主要流程、基本操作或核心代码、算法片段（该部分如不够填写，请另加附页）（1）编程实现对一组从键盘输入的数据，计算它们的最大值、最小值等，并输出。
要求：将计算过程写成一个函数，并采用引用参数实现值的求解。
程序代码部分：头文件：#define N 10000void comparason(double a[],int n,double &max,double &min);主函数：#include"stdio.h"#include"1.h"int main(){int n;printf("请输入数据个数\n");scanf("%d",&n);double a[N],max,min;int i;printf("请输入数据（空格隔开）\n");for(i=0;i<n;i++){scanf("%lf",&a[i]);}comparason(a,n,max,min);printf("最大值为%lf,最小值为%lf\n",max,min);return 0;}功能函数：#include"stdio.h"#include"1.h"void comparason(double a[],int n,double &max,double &min) {int i;max=a[0];min=a[0];for(i=0;i<n;i++){if(max<a[i]){max=a[i];}if(min>a[i]){min=a[i];}}return;}运行结果：（2）编程实现抽象数据类型三元组的定义、存储和基本操作，并设计一个主菜单完成各个功能的调用。
程序代码部分：头文件：#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef ElemType *Triplet;Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3);Status DestroyTriplet(Triplet &T);Status Get(Triplet T,int i,ElemType &e);Status Put(Triplet &T,int i,ElemType e);Status IsAscending(Triplet T);Status IsDescending(Triplet T);Status Max(Triplet T,ElemType &e);Status Min(Triplet T,ElemType &e);主函数：#include"stdio.h"#include"stdlib.h"#include"1.h"int main(){Triplet T;ElemType v1,v2,v3;printf("请输入三个数\n");scanf("%d%d%d",&v1,&v2,&v3);int x;InitTriplet(T,v1,v2,v3);do{printf("请选择下面操作\n");printf("1、销毁三元组\n");printf("2、查看第i个值\n");printf("3、修改第i个值\n");printf("4、判断是否为升序\n");printf("5、判断是否为降序\n");printf("6、查看最大值\n");printf("7、查看最小值\n");printf("0、结束程序！\n");scanf("%d",&x);switch(x){case 1:DestroyTriplet(T);printf("三元组已销毁，若想进行其他操作，需重启程序，新建三元组\n");break;case 2:printf("请输入要查看的位置\n");int a,e;scanf("%d",&a);Get(T,a,e);printf("第%d个值为%d\n",a,e);break;case 3:printf("请输入要修改的位置和数值\n");int b,c;scanf("%d%d",&b,&c);Put(T,b,c);printf("修改后三个值为%d,%d,%d\n",T[0],T[1],T[2]);break;case 4:int f;f=IsAscending(T);if(f==1)printf("是升序排列\n");elseprintf("不是升序排列\n");break;case 5:int g;g=IsDescending(T);if(g==1)printf("是降序排列\n");elseprintf("不是降序排列\n");break;case 6:int y;Max(T,y);printf("最大值为%d\n",y);break;case 7:int z;Min(T,z);printf("最小值为%d\n",z);break;case 0:printf("程序结束！\n");break;default:printf("输入出错！\n");}}while(x!=0&&x!=1);return 0;}功能函数：#include"stdio.h"#include"stdlib.h"#include"1.h"Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3) {T=(ElemType *)malloc(3*sizeof(ElemType));if(!T) exit(OVERFLOW);T[0]=v1;T[1]=v2;T[2]=v3;return OK;}Status DestroyTriplet(Triplet &T){free(T);T=NULL;return OK;}Status Get(Triplet T,int i,ElemType &e){if(i<1||i>3)return ERROR;e=T[i-1];return OK;}Status Put(Triplet &T,int i,ElemType e){if(i<1||i>3)return ERROR;T[i-1]=e;return OK;}Status IsAscending(Triplet T){return (T[0]<=T[1])&&(T[1]<=T[2]);}Status IsDescending(Triplet T){return (T[0]>=T[1])&&(T[1]>=T[2]);}Status Max(Triplet T,ElemType &e){e=(T[0]>=T[1])?((T[0]>=T[2])?T[0]:T[2]):((T[1]>=T[2])?T[1]:T[2]);return OK;}Status Min(Triplet T,ElemType &e){e=(T[0]<=T[1])?((T[0]<=T[2])?T[0]:T[2]):((T[1]<=T[2])?T[1]:T[2]);return OK;运行结果：四．实验结果的分析与评价（该部分如不够填写，请另加附页）1.三元组可含多个数据项；2.采用顺序存储方式；注：实验成绩等级分为（90－100分）优，（80－89分）良，(70-79分)中，（60－69分）及格，（59分）不及格。