ADT抽象数据类型三元组Triplet

---

目录大纲：

一、抽象数据类型的格式定义

二、抽象数据类型三元组Triplet的定义

三、抽象数据类型三元组Triplet的表示与实现

---

文章内容引用清华大学出版社严蔚敏版《数据结构》并加以笔者注释

---

一、抽象数据类型的格式定义

ADT抽象数据类型名{

数据对象：<数据对象的定义>

数据关系：<数据关系的定义>

基本操作：<基本操作的定义>

}ADT抽象数据类型名

其中，数据对象和数据关系的定义用伪码描述，基本操作的定义格式为

---

基本操作名（参数表）

初始条件：<初始条件描述>

操作结果：<操作结果描述>

---

基本操作有两种参数：赋值参数只为操作提供输入值；引用参数以&打头，除可提供输入值外，还将返回操作结果。

二、抽象数据类型三元组Triplet的定义

---

ADT Triplet{

数据对象：D = {e1, e2, e3|e1, e2, e3∈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元的值。

Put( &T, i, e)

初始条件：三元组T已存在，1≤i≤3

操作结果：改变T的第i元的值为e

IsAscending( T)

初始条件：三元组T已存在

操作结果：如果T的3个元素按升序排列，则返回1，否则返回0

IsDescending( T)

初始条件：三元组T已存在

操作结果：如果T的3个元素按降序排列，则返回1，否则返回0

Max( T, &e)

初始条件：三元组T已存在

操作结果：用e返回T的3个元素中的最大值。

Min( T, &e)

初始条件：三元组T已存在

操作结果：用e返回T的3个元素中的最小值。

}ADT Triplet

---

三、抽象数据类型三元组Triplet的表示与实现

#include <stdio.h>
#include <math.h>
#include <malloc.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

/*Status 是函数的类型，其值是函数结果状态代码*/ 
typedef int Status; 
/*数据元素类型*/ 
typedef float ElemType;
/*将Triplet类型定义为ElemType指针类型*/
typedef ElemType * Triplet;

/*构造三元组T，将元素e1, e2和e3分别赋以参数v1,v2和v3的值*/ 
Status InitTriplet(Triplet &T, ElemType v1, ElemType v2, ElemType v3);

/*销毁三元组T*/ 
Status DestroyTriplet(Triplet &T);

/*使用e返回T的第i元的值*/ 
Status Get(Triplet T, int i, ElemType &e);

/*改变T的第i元的值为e*/ 
Status Put(Triplet &T, int i, ElemType e); 

/*若三元组T的元素为升序排列，则返回1，否则返回0*/ 
Status IsAscending(Triplet T); 

/*若三元组T的元素为降序排列，则返回1，否则返回0*/ 
Status IsDescending(Triplet T);

/*使用e返回T的3个元素中的最大值*/ 
Status Max(Triplet T, ElemType &e); 

/*使用e返回T的3个元素中的最小值*/ 
Status Min(Triplet T, ElemType &e);

int main()
{
    /*定义三个三元组*/ 
    Triplet T1, T2, T3;
    
    /*分别初始化三个三元组 */
    InitTriplet(T1, 1, 2.3, 1.2);
    InitTriplet(T2, 2, 3, 4);
    InitTriplet(T3, 5, 3, 1);
    
    ElemType e;
    /*获取T1中的第一个元素*/ 
    if(Get(T1, 1, e)) 
    {
        /*函数调用成功*/
        printf("T1的第1个元素值为%.2f\n", e); 
    }
    
    e = 2.1;
    /*修改T1中的第一个元素*/ 
    if(Put(T1, 1, e)) 
    { 
        printf("修改后的T1的第1个元素值为%.2f\n", e);         
    }
    
    /*获取T2的最大元素*/ 
    if(Max(T2, e))
    {
        printf("T2的最大元素值为%.2f\n", e);     
    }
    
    /*获取T3的最小元素*/
    if(Min(T3, e)) 
    {
        printf("T3的最小元素值为%.2f\n", e);     
    }
    
    /*判断T2是否为升序*/
    if(IsAscending(T2)) 
    {
        printf("T2元素为升序排列\n");
    }
    
    /*判断T3是否为降序*/ 
    if(IsDescending(T3))
    {
        printf("T3元素为降序排列\n");    
    }
        
    /*结束时销毁三元组，回收空间*/ 
    DestroyTriplet(T1);
    DestroyTriplet(T2);
    DestroyTriplet(T3); 
    return 0;
}

/*初始化三元组*/ 
Status InitTriplet(Triplet &T, ElemType v1, ElemType v2, ElemType v3)
{
    T = (ElemType *)malloc(3 * sizeof(ElemType));    //分配3个元素的存储空间
    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;
}

/*使用e获取第i个元素的值*/ 
Status Get(Triplet T, int i, ElemType &e)
{
    /*检查元素是否存在*/ 
    if(i < 1 || i > 3)
        return ERROR;
    e = T[i - 1];
    return OK;
}

/*改变T中第i个元素的值为e*/ 
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]); 
}

/*返回三元组中最大的元素值，赋值给e*/ 
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; 
}

/*返回三元组中最小的元素值，赋值给e*/ 
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; 
}