三元组ADT (数据结构C语言版) C++实现

很久没用C语言，都忘了C语言中没有引用参数，下面的代码中用到了C语言没有的引用参数。

首先是一些表示状态的全局变量

common.h

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERLOW -2
typedef int Status;

然后是三元组ADT的头文件，包含了三元组的函数声明

triplet.h

#include "common.h"

//--------采用动态分配的顺序存储结构-----
typedef int ElemType;
typedef ElemType* Triplet; //由InitTriplet分配3个元素的存储空间

//--------基本操作的函数原型说明------
Status InitTriplet(Triplet &T, ElemType v1, ElemType v2, ElemType v3);
//操作结果：构造三元组T，元素e1,e2,e3分别被赋以参数v1,v2,v3的值

Status DestroyTriplet(Triplet &T);
//操作结果：三元组T被销毁

ElemType Get(Triplet T, int i, ElemType &e);
//初始条件：三元组T已存在，1<=i<=3
//操作结果：用e返回T的第i元的值

Status Put(Triplet &T, int i, ElemType e);
//初始条件：三元组T已存在，1<=i<=3
//操作结果：改变T的第i元的值为e

Status IsAscending(Triplet T);
//初始条件：三元组已存在
//操作结果：如果T的三个元素按升序排列，则返回1，否则返回0

Status IsDescending(Triplet T);
//初始条件：三元组T已存在
//操作结果：如果T的三个元素按降序排列，则返回1，否则返回0

Status Max(Triplet T, ElemType &e);
//初始条件：三元组T已存在
//操作结果：用e返回T的三个元素中的最大值

Status Min(Triplet T, ElemType &e);
//初始条件：三元组T已存在
//操作结果：用e返回T的三个元素中的最小值

最后是triplet函数的定义以及main函数

source.cpp

#include<stdio.h>
#include<stdlib.h>
#include "triplet.h"

//------------基本操作的实现------------
Status InitTriplet(Triplet &T, ElemType v1, ElemType v2, ElemType v3){
    //构造三元组T，依次置T的3个元素的初始值为v1,v2,v3
    T = (ElemType *)malloc(3 * sizeof(ElemType)); //分配3个元素的存储空间
    if (!T){
        exit(OVERLOW); //分配存储空间失败
    }
    T[0] = v1; T[1] = v2; T[2] = v3;
    return OK;
} //InitTriplet

Status DestroyTriplet(Triplet &T){
    //销毁三元组T
    free(T); T = NULL;
    return OK;
}//DestroyTriplet

ElemType Get(Triplet T, int i, ElemType &e){
    //1<=i<=3, 用e返回T的第i元的值
    if (i<1 || i>3) return ERROR;
    e = T[i - 1];
    return OK;
}//Get

Status Put(Triplet &T, int i, ElemType e){
    //1<=i<=3, 用e赋值给T[i]
    if (i<1 || i>3) return ERROR;
    T[i - 1] = e;
    return OK;
}//Put

Status IsAscending(Triplet T){
    //如果T的三个元素按照升序排列，则返回1，否则返回0
    return (T[0] <= T[1]) && (T[1] <= T[2]);
}//IsAscending

Status IsDecending(Triplet T){
    //如果T的三个元素按照降序排列，则返回1，否则返回0
    return (T[0] >= T[1]) && (T[1] >= T[2]);
}//IsDescending

Status Max(Triplet T, ElemType &e){
    //用e返回T的三个元素中的最大值
    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的三个元素中的最小值
    e = (T[0] <= T[1]) ? ((T[0] <= T[2]) ? T[0] : T[2]) :
        ((T[1] <= T[2]) ? T[1] : T[2]);
    return OK;
}

int main(){
    Triplet T;
    Status state = InitTriplet(T, 1, 2, 3);
    printf("state: %d
", state);

    ElemType e;
    Get(T, 3, e);
    printf("T[i]=%d
", e);

    ElemType t1, t2, t3;
    printf("sizeof T:%d
", sizeof(T));
    Get(T, 1, t1);
    Get(T, 2, t2);
    Get(T, 3, t3);
    printf("t1=%d;t2=%d;t3=%d
", t1, t2, t3);

    Put(T, 1, 10);
    printf("T[1]=%d
", T[0]);
    ElemType max, min;
    Max(T, max);
    Min(T, min);
    printf("max=%d
", max);
    printf("min=%d
", min);

    Status s1 = DestroyTriplet(T);
    printf("destroy state: %d
", s1);

    getchar();
    return 0;
}