C 语言实现 数据结构 三元组

C 语言实现 数据结构 三元组（原来的邮箱帐号不能用了，拷贝到该帐号）

#include <stdio.h>
#include <stdlib.h>
 
#define OK        1
#define ERROR     0
#define OVERFLOW  -2
typedef int       Status;
typedef int       ElemType;
typedef ElemType* Triplet;
 
Status InitTriplet(Triplet *T, ElemType v1, ElemType v2, ElemType v3);
Status DestroyTriplet(Triplet *T);
Status Get(Triplet T, int i, ElemType *e);
Status Put(Triplet *T, int i, ElemType e);
Status IsAscending(Triplet T);
Status IsDescending(Triplet T);
Status Max(Triplet T, ElemType *e);
Status Min(Triplet T, ElemType *e);
 
int main()
{
	Triplet T;
	ElemType e, e1=11, e2=55, e3=99;
 
	if (!InitTriplet(&T, e1, e2, e3))
        return 0;
 
	Max(T, &e);
	printf("最大的元素: %d\n", e);
 
	Min(T, &e);
	printf("最小的元素: %d\n", e);
 
	printf("按升序排列: %d\n", IsAscending(T));
	printf("按降序排列: %d\n", IsDescending(T));
 
	DestroyTriplet(&T);
	return 0;
}
 
/**< 初始化三元组, 并赋予v1, v2, v3的值 */
Status InitTriplet(Triplet *T, ElemType v1, ElemType v2, ElemType v3)
{
    *T = (ElemType *)malloc(3*sizeof(ElemType));
 
    if (!T) exit(OVERFLOW);
 
    (*T)[0] = v1;
    (*T)[1] = v2;
    (*T)[2] = v3;
    return OK;
}
 
/**< 销毁三元组，释放内存 */
Status DestroyTriplet(Triplet *T)
{
    free(*T);
    return OK;
}
 
/**< 用 e 保存三元组 T 中第 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;
}
 
/**< 若三元组 T 中元素按升序排列，返回1， 否则返回0 */
Status IsAscending(Triplet T)
{
    return T[0]<=T[1] && T[1]<=T[2];
}
 
/**< 若三元组 T 中元素按降序排列，返回1， 否则返回0 */
Status IsDescending(Triplet T)
{
    return T[0]>=T[1] && T[1]>=T[2];
}
 
/**< 用 e 保存三元组 T 中最大值 */
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 保存三元组 T 中最小值 */
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;
}