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 3
using 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);
else
e = T[i - 1];
}
// 修改T第i个位置为e
void putElem(Triplet &T,int i,ElemType e)
{
if(i < 1 || i > N)printf("位序应在1 ~ %d 之间",N);
else
T[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);
else
e = 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);
else
T[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;
}
2700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
