数据结构C语言实现——ADT Triplet

declartion.h    //类型声明

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define ElemType int
typedef ElemType* Triplet;
typedef int Status;

function.h     //函数声明

#ifndef FUNCTION_H_INCLUDED
#define FUNCTION_H_INCLUDED
Status InitTriplet(Triplet *T, ElemType v1, ElemType v2, ElemType v3);
//操作结果:构造了三元组T，元素e1, e2, e3分别被赋以参数v1, v2, v3的值
Status DestroyTriplet(Triplet *T);
//操作结果:三元组T被销毁
Status 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元的值
Status IsAscending(Triplet T);
//初始条件:三元组T已存在;
//如果T的3个元素按升序排列，则返回1，否则返回0
Status IsDescending(Triplet T);
//初始条件:三元组T已存在;
//如果T的3个元素按降序排列，则返回1，否则返回0
Status Max(Triplet T, ElemType *e);
//初始条件:三元组T已存在;
//操作结果:用e返回T中的3个元素的最大值
Status Min(Triplet T, ElemType *e);
//初始条件:三元组T已存在;
//操作结果:用e返回T中的3个元素的最小值

#endif // FUNCTION_H_INCLUDED

function.c    //函数的定义

#include <stdio.h>
#include <stdlib.h>
#include "declartion.h"
Status InitTriplet(Triplet *T, ElemType v1, ElemType v2, ElemType v3)
{
        //操作结果：构造三元组T，元素e1, e2, e3分别被赋以参数v1,v2,v3的值
        (*T)=(ElemType *)malloc(3*sizeof(ElemType));
        if(!T)          exit(OVERFLOW);
        (*T)[0]=v1;         (*T)[1]=v2;        (*T)[2]=v3;
       printf("%x       %x     %d\n", T, *T,  (*T)[0]);
      printf("%x       %x     %d\n", T+1, *(T+1),  *((*T)+1));
       printf("%x       %x       %d\n", T+2, *(T+2),  (*T)[2]);
        return OK;
}//InitTriplet

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

Status Get(Triplet T, int i, ElemType *e)
{
        //初始条件：三元组T已存在，1<=i<=3;
        //操作结果：用
        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,置T的第i元素的值为e
        if(i<1 || i>3)          return ERROR;
        (*T)[i-1]=e;
        return OK;
}//Put

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

Status IsDescending(Triplet T)
{
        //如果T的3个元素按降序排列，则返回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;
}//Max

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;
}//Min

main.c

#include <stdio.h>
#include <stdlib.h>
#include "declartion.h"
#include "function.h"
int main()
{
        ElemType e;
        Triplet *T=(Triplet *)malloc(sizeof(Triplet));
        InitTriplet(T,1,2,3);

        Get(*T, 2, &e);
        printf("T中第二个元素为：%d\n", e);

        if(IsAscending(*T) == OK)       printf("IsAscending\n");

        Min(*T, &e);        printf("Min is %d\n", e);
        Max(*T, &e);        printf("Max is %d\n", e);

        if(Put(T, 1, 4) ==OK)
        {
                Get(*T, 1, &e);
                printf("T[0] is %d\n",e);
        }

        if(DestroyTriplet(T) == OK)     printf("DestroyTriplet success");
        return 0;
}

运行结果