1.基本要求

（1）写出抽象数据类型的定义，即数据对象、数据关系、基本操作
（2）用结构体封装需要定义的数据类型，如定义ADT三元组时，首先用结构体封装“三元组”的三个分量。并利用typedef对结构体重新命名。
（3）用C语言实现基本操作的定义与调用
ADT 抽象数据类型名 {
数据对象：<数据对象的定义>
数据关系：<数据关系的定义>
基本操作：<基本操作的定义>
}ADT抽象数据类型名

***5.实验源代码***
//（1）写出抽象数据类型的定义，即数据对象、数据关系、基本操作
//（2）用结构体封装需要定义的数据类型，如定义三元组ADT时，首先用结构体封装“三元组”的三个分量。并利用typedef对结构体重新命名。
//（3）完成基本操作的C语言实现与调用
#include<stdio.h>
#define OK 1
#define ERROR 0
typedef int Status;
//三元组的类型先定义为float，可以随时变换成别的类型
typedef float ElemType;
typedef struct
{
ElemType e[3];
}Triplet;
//三元组的初始化
Status initTriplet(Triplet &T,ElemType v0,ElemType v1,ElemType v2)
{
T.e[0]=v0;
T.e[1]=v1;
T.e[2]=v2;
return OK;
}
//销毁三元组,静态存储是在程序开始的时候就分配固定的内存单元，整个程序结束后自动释放存储单元，不需销毁
//而动态存储单元在程序运行初不分配内存单元在用到时才分配，而当用过后需要用语句释放该内存空间
Status destoryTriplet(Triplet &T)
{
return OK;
}
//用e获取T的第i(1~3)个元素的值
Status getElem(Triplet T,int i,ElemType &e)
{
if(i<1||i>3)
return ERROR;
else e=T.e[i-1];
return OK;
}
//置T的第i元的值为e
Status putElem(Triplet &T,int i,ElemType e)
{
if(i<1||i>3)
return ERROR;
else T.e[i-1]=e;
return OK;
}
//如果T的三个元素按升序排列，则返回1，否则返回0
Status isAscending(Triplet T)
{
return(T.e[0]<=T.e[1]&&T.e[1]<=T.e[2]);
}
//如果T的三个元素按降序排列，则返回1，否则返回0
Status isDescending(Triplet T)
{
return(T.e[0]>=T.e[1]&&T.e[1]>=T.e[2]);
}
//用e返回指向T的最大元素的值
ElemType getMax(Triplet T,ElemType &e)
{
if(T.e[0]>T.e[1])
e=T.e[0];
else
e=T.e[1];
if(T.e[2]>e)
e=T.e[2];
return e;
}
//用e返回指向T的最小元素的值
ElemType getMin(Triplet T,ElemType &e)
{
if(T.e[0]<T.e[1])
e=T.e[0];
else
e=T.e[1];
if(T.e[2]<e)
e=T.e[2];
return e;
}
//测试程序
int main()
{
Triplet T;
Status flag;
ElemType v0,v1,v2,e;
printf("请进入三元组的三个值v0,v1,v2:\n");
scanf("%f,%f,%f",&v0,&v1,&v2);
flag=initTriplet(T,v0,v1,v2);
printf
("调用初始化函数后，flag=%d,T的三个值为%4.2f,%4.2f,%4.2f\n",flag,T.e[0],T.e[1],T.e[2]);
if(isAscending(T))
printf("该三元组元素为升序\n");
if(isDescending(T))
printf("该三元组元素为降序\n");
printf
("该三元组中的最大值为:%4.2f,最小值为:%4.2f",getMax(T,e),getMin(T,e));
return OK;

数据类型描述（此处写清楚三元组的抽象数据类型描述
ADT Triplet{
数据对象：D = {e1,e2,e3 | e1,e2,e3属于ElemType}
数据关系：R = { <e1，e2> ， <e2，e3> }
基本操作：
initTriplet(&T,v1,v2,v3)
初始条件：无
操作结果：构造三元组T，元素e1，e2和e3分别被赋予参数v1,v2,v3的值。

DestroyTriplet(&T)
初始条件：三元组T已经存在。
操作结果：销毁三元组T。
getElem(T,i,&e)
初始条件：三元组T已经存在，1<=i<=3.
操作结果：用e返回三元组T的第i个元素。
putElem(&T,i,e)
初始条件：三元组T已经存在，1<=i<=3.
操作结果：将T的第i个元素的值置为e。

IsAscending(T)
初始条件：三元组T已经存在。
操作结果：如果三元组T的三个元素按升序排列，则返回TRUE；否则返回FALSE。
IsDescending(T)
初始条件：三元组T已经存在。
操作结果：如果三元组T的三个元素按降序排列，则返回TRUE，否则返回FALSE。
getMax(T,&e)
初始条件：三元组T已经存在。
操作结果：用e返回T的3个元素中的最大值。
getMin(T,&e)
初始条件：三元组T已经存在。
操作结果：用e返回T的3个元素中的最小值。
}ADT Triplet

2.基本要求

设计实现抽象数据类型“三元组”，要求动态分配内存。每个三元组由任意三个实数的序列构成，基本操作包括：创建一个三元组，取三元组的任意一个分量，置三元组的任意一个分量，求三元组的最大分量，求三元组的最小分量，显示三元组，销毁三元组等。
实验源码：

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>  //*********************自定义符号常量**************************
# define OK 1
# define ERROR 0
# define TRUE 1
# define FALSE 0
# define OVERFLOW -1  //********************自定义数据类型**************************
typedef int Status;
typedef int ElemType;
typedef ElemType * Triplet;  //*******************三元组的主要操作*************************  /*
函数：createTriplet
参数：Triplet &T 三元组引用
返回值：无
作用：创建三元组
*/
void createTriplet(Triplet &T){  T = (Triplet)malloc(sizeof(ElemType));
if(!T){ //if(!T) <=> if(T == null)
printf("申请内存失败！\n");
exit(OVERFLOW);
}//if
}//createTriplet  /*
函数：InitTriplet
参数：Triplet &T 三元组引用
ElemType v1 三元组第一个分量
ElemType v2 三元组第二个分量
ElemType v3 三元组第三个分量
返回值：状态码，OK表示操作成功
作用：初始化三元组
*/
Status InitTriplet(Triplet &T, ElemType v1,ElemType v2,ElemType v3){  //创建一个三元组
createTriplet(T);  //初始化三元组的三个分量
T[0] = v1;
T[1] = v2;
T[2] = v3;  //操作成功
return OK;
}//InitTriplet  /*
函数：DestroyTriplet
参数：Triplet &T 三元组引用
返回值：状态码，OK表示操作成功
作用：销毁三元组
*/
Status DestroyTriplet(Triplet &T){  free(T);   //释放内存空间
T = NULL;  //指针清零
return OK; //操作成功
}//DestroyTriplet  /*
函数：getElem
参数：Triplet T 三元组结构体指针
int i 索引变量，指示三元组中的第几个分量
ElemType &e 带回的元素E
返回值：状态码，OK表示操作成功
作用：取出三元组第i个分量存储的数据
*/
Status getElem(Triplet T, int i, ElemType &e){  //检查索引变量i是否越界
if(i < 1 || i > 3){
return ERROR;
}//if  //取出对应位置元素
e = T[i - 1];  //操作成功
return OK;
}//getElem  /*
函数：putElem
参数：Triplet &T 三元组引用
int i 索引变量，指示三元组中的第几个分量
ElemType &e 带回的元素E
返回值：状态码，OK表示操作成功
作用：修改三元组第i个分量的值
*/
Status putElem(Triplet &T, int i, ElemType e){  //检查索引变量是否正确
if(i < 1 || i > 3) {
return ERROR;
}//if  //修改元素的值
T[i - 1] = e;  //操作成功
return OK;
}//putElem  /*
函数：isAscending
参数：Triplet T 三元组结构体指针
返回值：如果三元组的三个元素按升序排列，则返回TRUE；否则返回FALSE。
作用：判断三元组是否升序排列
*/
Status isAscending(Triplet T){  return T[0] <= T[1] && T[1] <= T[2];
}//isAscending  /*
函数：isDescending
参数：Triplet T 三元组结构体指针
返回值：如果三元组的三个元素按降序排列，则返回TRUE；否则返回FALSE。
作用：判断三元组是否降序排列
*/
Status isDescending(Triplet T){  return T[0] >= T[1] && T[1] >= T[2];
}//isDescending  /*
函数：getMax
参数：Triplet T 三元组结构体指针
ElemType &e 带回三元组中三个分量的最大值
返回值：状态码，OK表示操作成功
作用：获得三元组中三个分量的最大值
*/
Status getMax(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;
}//getMax  /*
函数：getMin
参数：Triplet T 三元组结构体指针
ElemType &e 带回三元组中三个分量的最小值
返回值：状态码，OK表示操作成功
作用：获得三元组中三个分量的最小值
*/
Status getMin(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;
}//getMin  //-----------------------主函数---------------------------------
int main(){  Triplet T;
ElemType v0, v1, v2, e;
Status flag, temp, temp1;  printf("请输入v0，v1，v2:");
scanf("%d,%d,%d", &v0, &v1, &v2);
flag = InitTriplet(T, v0, v1, v2);
printf("调用初始化函数后，flag=%d(1:成功) T的三个值为:%d %d %d\n", flag, T[0], T[1], T[2]);  printf("您想查找三元组第几个元素的值(1-3)：\n");
scanf("%d", &temp);
getElem(T, temp, e);
printf("三元组第%d个元素的值：%d\n", temp, e);  printf("您想重置三元组第几个元素的值(1-3)：\n");
scanf("%d", &temp);
printf("您想重置三元组第%d个元素的值为多少?：\n", temp);
scanf("%d", &temp1);
putElem(T, temp, temp1);
printf("三元组第%d个元素重置后的值：%d\n", temp, T[temp-1]);
printf("重置第%d个元素后三元组的三个值为：%4d,%4d,%4d\n", temp, T[0], T[1], T[2]);  if(isAscending(T)) //判断三元组是否为升序
printf("该三元组元素为升序！\n");
else if(isDescending(T)) //再判断三元组是否为降序
printf("该三元组元素为降序！\n");
else  //若以上两条件均不符合则提示用户既不是升序也不是降序
printf("该三元组元素既不是升序也不是降序！\n");  //输出三元组的最大值和最小值
getMax(T, e);
printf("该三元组中的最大值为：%4d\n", e);
getMin(T, e);
printf("该三元组中的最小值为：%4d\n", e);  printf("销毁三元组\n");
DestroyTriplet(T);  return 0;
}

3.带菜单版本

1.c++实现

#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<cstring>
#include<algorithm>#define N 3using namespace std;typedef float ElemType;
typedef ElemType *Triplet;//初始化N元组
void initTriplet(Triplet &T,ElemType v[])
{T = (ElemType *)malloc(sizeof (ElemType) * N);if (!T) exit( -2 );for (int i = 0; i < N ; i ++){T[i] = v[i];}
}//输出N元组
void printTriplet(Triplet T)
{for (int i = 0 ; i < N ; i ++){printf("%.1f\t",T[i]);}puts("");
}//两个N元组相加
void add(Triplet T1,Triplet &T2)
{for (int i = 0 ; i < N ; i ++){T2[i] += T1[i];}
}//N元组各分量同乘比例系数
void mulCoef(Triplet &T1,float coef)
{for (int i = 0; i < N ; i ++){T1[i] *= coef;}
}//获取T第i个位置的数
void getElem(Triplet T,int i,ElemType &e)
{if (i < 1 || i > N)printf("位序应在1 ~ %d 之间",N);elsee = T[i - 1];
}// 修改T第i个位置为e
void putElem(Triplet &T,int i,ElemType e)
{if(i < 1 || i > N)printf("位序应在1 ~ %d 之间",N);elseT[i - 1] = e;
} //是否升序
bool isAscending(Triplet T)
{for (int i = 0 ; i < N - 1; i ++)if(T[i] >= T[i + 1])return false;return true;
}//是否降序
bool isDescending(Triplet T)
{for (int i = 0 ;i < N - 1; i ++)if(T[i] <= T[i + 1])return false;return true;
}//找最大值
ElemType getmax(Triplet T,ElemType &e)
{e = T[0];for (int i = 0 ; i < N ; i ++)e = max(e,T[i]);return e;
}//找最小值
ElemType getmin(Triplet T,ElemType &e)
{e = T[0];for (int i = 0 ; i < N ; i ++)e = min(e,T[i]);return e;
}//排序
void Sort(Triplet &T)
{sort(T,T + N);
}//销毁三元组,退出系统
void destroy(Triplet &T)
{if(!T)free(T);exit(0);
}int main()
{Triplet T1,T2;int funNum,i;ElemType v[N],e,coef;printf("----N元组操作主菜单----\n");printf("1.N元组初始化\n");printf("2.输出N元组\n");printf("3.用e获取T的第i个元素的值\n");printf("4.置T的第i元为e\n");printf("5.是否升序排列\n");printf("6.是否降序排列\n");printf("7.取最大值\n");printf("8.取最小值\n");printf("9.输入另一个N元组相加\n");printf("10.N元组元素乘比例系数\n");printf("11.对N元组进行排序\n");printf("12.退出系统\n");while(1){printf("请输入你想完成的功能编号：\n");cin>>funNum;switch(funNum){case 1: printf("请输入N元组的每个元素（N = %d)\n",N);for (int i = 0 ; i < N ; i ++) cin>>v[i];initTriplet(T1,v);break;case 2:printf("初始化好的N元组为：\n");printTriplet(T1);break;case 3:printf("请输入要获取第几个元素的值：\n");cin>>i;getElem(T1,i,e);printf("第%d个元素的值为：%.1f\n",i,e);break; case 4 :printf("请输入要改变的位置和更改后的值: \n");cin>>i>>e;putElem(T1,i,e);printf("新的N元组为: \n");printTriplet(T1);break;case 5:if (isAscending(T1)) puts("升序排列");else puts("非升序排列");break;case 6:if (isDescending(T1)) puts("降序排列");else puts("非降序排列");break;case 7:getmax (T1,e);printf("最大的值为:%.1lf\n",e);break;case 8:getmin (T1,e);printf("最小的值为:%.1lf\n",e);break;      case 9:printf("请输入另一个N元组的每个元素（N = %d)\n",N);for(int i = 0; i < N ;i ++)cin>>v[i];initTriplet(T2,v);add(T1,T2);printf("相加之后的N（N = %d)元组为：\n",N);printTriplet(T2);break;case 10:printf("请输入所乘的系数：");cin>>coef;mulCoef(T1,coef);printf("相乘后N元组为: \n");printTriplet(T1);break;case 11:printf("排序前的N元组为: \n");printTriplet(T1);Sort(T1);printf("排序后的N元组为：\n");printTriplet(T1);break;case 12:destroy(T1);destroy(T2);break;default:printf("没有你想完成的功能\n");break;}}return 0;
}

2.C语言实现

#include <stdio.h>
#include <stdlib.h>
# define N 3
typedef int Status;
typedef float ElemType;
typedef ElemType *Triplet;// 初始化三元组
void creatTriplet (Triplet &T, ElemType v[])
{T = (ElemType *)malloc(sizeof (ElemType) * N);if (!T)  exit(-2);Status i;for (i=0; i<N; i++){T[i] = v[i];} //printf("\n");
}
// 取三元组的任意一个分量
void GetTriplet (Triplet T,int n, ElemType &e)
{int i;printf("请输入要取的三元组中的第n个值（n=?）");scanf ("%d",&n);if (n < 1 || n > N)printf("位序应在1 ~ %d 之间",N);elsee = T[n - 1];printf("第%d个元素的值为：%.1f\n",n,e);
}
// 置三元组的任意一个分量
void PutTriplet (Triplet &T, ElemType e)
{int i,n;printf("请输入要置换的三元组中的第n个值（n = ?）");scanf("%d", &n);if(n < 1 || n > N)printf("位序应在1 ~ %d 之间",N);elseT[n - 1] = e;
}
// 取最大值
void MaxTriplet (Triplet T, ElemType &e)
{e = T[0];if (T[1] > T[0]){e = T[1];if (T[2] > T[1])e = T[2];}else if(T[2] > T[0])  e = T[2];printf("三元组中的最大值为：%.1f", e);printf("\n");
}
// 取最小值
void MinTriplet (Triplet T, ElemType &e)
{e = T[0];if (T[1] < T[0]){e = T[1];if (T[2] < T[1])e = T[2];}else if(T[2] < T[0])  e = T[2];printf("三元组中的最小值为：%.1f", e);printf("\n");
}
// 显示三元组
void printTriplet (Triplet T)
{int i;for (i=0; i<N; i++){printf("%.1f\t",T[i]);}printf("\n");
}
// 三元组的各分量同乘一个比例因子
void mulCoefTripet (Triplet &T)
{int Coef,i; printf("请输入三元组要乘的比例因子：");scanf("%d", &Coef);for (i=0; i<N; i++){T[i] *= Coef;}printf("处理之后的三元组为："); for (i=0; i < N;i++){printf("%.1f\t", T[i]);} printf("\n");}
// 两个三元组对应分量相加
void add(Triplet T1, Triplet &T2)
{for (int i = 0;i< N; i++){T2[i] += T1[i];}
}
// 冒泡排序输出（升序）
void Sort(Triplet &T)
{for(int i=0;i<N-1;i++){for(int j=0;j<N-i-1;j++){if(T[j]>T[j+1]){int tmp = T[j];T[j] = T[j+1];T[j+1] = tmp;}}}printf("排序后的三元组为：\n");for(int i=0; i<N; i++){printf("%.1f\t",T[i]);}
}
//是否降序
bool isDescending(Triplet T)
{for (int i = 0 ;i < N - 1; i ++)if(T[i] <= T[i + 1]) return false;return true;
}
//是否升序
bool isAscending(Triplet T)
{for (int i = 0 ; i < N - 1; i ++)if(T[i] >= T[i + 1]) return false;return true;
}
// 销毁三元组
void DestroyTriplet (Triplet &T)
{free (T);exit (-2);
}
int main()
{int n;ElemType v[N];ElemType e;int i;printf("请输入你要创建的三元组中的值：\n");for (i = 0 ; i < 3 ; i++){scanf("%f", &v[i]);}Triplet T1;Triplet T2;printf("正在创建三元组....."); creatTriplet(T1, v);printTriplet (T1);printf("1.  取三元组的任意一个分量：\n");printf("2.  置三元组的任意一个分量：\n");printf("3.  求三元组的最大分量：\n");printf("4.  求三元组的最小分量：\n");printf("5.  显示三元组：\n");printf("6.  三元组的各分量同乘一个比例因子：\n");printf("7.  两个三元组对应分量相加：\n");printf("8.  冒泡排序：\n");printf("9.  是否降序排序\n");printf("10. 是否升序排序\n");printf("11. 销毁三元组：\n"); while (1){printf("请输入你想完成的功能编号：");scanf("%d",&n);switch (n) {case 1: GetTriplet (T1,n,e);break;case 2: printf("请输入一个值用来代替三元组中的一个值：");scanf("%f", &e); PutTriplet (T1,e);break;case 3: MaxTriplet (T1, e);break;case 4: MinTriplet (T1, e);break;case 5: printTriplet (T1);break;case 6: mulCoefTripet (T1);break;case 7: printf("请输入另一个N元组的每个元素（N = %d)\n",N);for(int i = 0; i < N ;i ++)scanf("%f",&v[i]);creatTriplet(T2,v);add(T1,T2);printf("相加之后的N（N = %d)元组为：\n",N);printTriplet(T2);add(T1, T2);break;case 8: Sort(T1);break;case 9: if (isDescending(T1)) printf("降序排列\n");else printf("非降序排列\n");break;case 10:if (isAscending(T1)) printf("升序排列\n");else printf("非升序排列\n");break;case 11:DestroyTriplet (T1);break;default:printf("没有你想完成的功能\n");break;}}return 0;
}

三元组的抽象数据类型相关推荐

抽象数据类型的三元组C语言,试仿照三元组的抽象数据类型分别写出数据类型复数和有理数的定义？...
满意答案 hweiwei420 2015.10.10 采纳率:50% 等级:13 已帮助:14203人 a. 抽象数据类型复数complex: ADT complex{ 数据对象:D={e1,e ...
仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义
ADT Complex{ 数据对象:D={r,i | r,i为实数} 数据关系:S={<r,i>} 基本操作: InitComplex(&C,re,im) 操作结果:构造一个复数C ...
抽象数据类型与计算机内部表示和实现无关,实验02 抽象数据类型的表示与实现.doc...
文档介绍: EvaluationWarning:ThedocumentwascreatedwithSpire..蕊歼植罩胖什塌浦有夏禽院灼屉重陕馆谗肘钡枪帽潭裙富队捌狞栅试颅蛆占芝虞却轮侠靛崎刑漆联斤 ...
抽象数据类型三元组表示与实现
1,抽象数据类型概念: (1)由用户定义,用以表示应用问题的数据模型:(2)由基本的数据类型组成, 并包括一组相关的操作: 2,抽象数据类型用三元组表示:ADT = (D,S,P) D: 数据对象 ...
数据结构--抽象数据类型三元组Triplet的表示和实现
抽象数据类型三元组Triplet的表示和实现. 数据类型是一个值的集合和定义在这个值集上的一组操作的总称.按"值"的不同特性,高级程序语言中的数据类型可分为两类:一类是非结构的原子 ...
数据结构简介以及抽象数据类型的实现
数据结构简介数据结构(英语:data structure)是计算机中存储.组织数据的方式. 数据结构意味着接口或封装:一个数据结构可被视为两个函数之间的接口,或者是由数据类型联合组成的存储内容的访问 ...
实验报告：抽象数据类型的表现和实现
实验报告:抽象数据类型的表现和实现实验内容基本要求: 设计实现抽象数据类型"三元组",要求动态分配内存.每个三元组由任意三个实数的序列构成,基本操作包括:创建一个三元组,取三元 ...
数据结构的基本概念和抽象数据类型
1.基本概念和术语数据:是对客观事物的符号表示. 数据元素:数据的基本单位,一个数据元素可由若干个数据项组成,数据项是数据的不可分割的最小单位数据对象:性质相同的数据元素的集合是数据的一个子集数 ...
【二】、什么是抽象数据类型
[二].什么是抽象数据类型前言在上一篇[什么是数据结构]中我详细介绍了我对数据结构的理解,其实描述数据结构,有一个很好的方法叫抽象数据类型.下面我会详细介绍抽象数据类型. 抽象数据类型抽象数据类 ...

三元组的抽象数据类型