三元组的抽象数据类型

算法 专栏收录该内容
17 篇文章 1 订阅

三元组的抽象数据类型

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.带菜单版本

#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
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 鲸 设计师:meimeiellie 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值