数据结构：三元组（Triplet）基本操作的算法描述（C语言）

作者在学习数据结构时，发现鲜有完全按照 C 语言描述的算法操作，这让习惯于写 .c 而不是 .cpp 的初学者很是头疼。本文将基于 C 语言描述算法操作，如有错漏还望大佬们指正。

---

前言

本文将按照严惠敏所著《数据结构(C语言版)》所做的函数原型声明进行算法描述，由于C语言不支持函数参数中出现取地址符，我将函数参数更改为指针，调用函数时需要使用一级指针。新增了打印函数 PrintTriplet； 三元组的基本操作调用示例将在本文后给出。

---

一、三元组基本操作的函数声明

//构造三元组 T，依次置 T 的三个元素的初值为 v1, v2 和 v3
extern Status InitTriplet(Triplet* T, ElemType v1, ElemType v2, ElemType v3);
//销毁三元组 T
extern Status DestroyTriplet(Triplet* T);
//1 <= i <= 3，用 e 返回 T 的第 i 元的值
extern Status Get(Triplet T, int i, ElemType* e);
//1 <= i <= 3，改变 T 的第 i 元的值为 e
extern Status Put(Triplet* T, int i, ElemType e);
//如果 T 的 3 个元素按升序排列，则返回 1，否则返回 0
extern Status IsAscending(Triplet T);
//如果 T 的 3 个元素按降序排列，则返回 1，否则返回 0
extern Status IsDescending(Triplet T);
//用 e 返回指向 T 的最大元素的值
extern Status Max(Triplet T, ElemType* e);
//用 e 返回指向 T 的最小元素的值
extern Status Min(Triplet T, ElemType* e);
//打印三元组，中间以空格隔开
extern Status PrintTriplet(Triplet T);

二、三元组基本操作的完整描述

/* 三元组 */
#include <stdio.h>
#include <stdlib.h>
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW    -2

typedef int Status;
typedef int ElemType;

//--------采用动态分配的顺序存储结构--------
typedef ElemType* Triplet;

//--------基本操作的函数原型说明--------

//构造三元组 T，依次置 T 的三个元素的初值为 v1, v2 和 v3
extern Status InitTriplet(Triplet* T, ElemType v1, ElemType v2, ElemType v3);
//销毁三元组 T
extern Status DestroyTriplet(Triplet* T);
//1 <= i <= 3，用 e 返回 T 的第 i 元的值
extern Status Get(Triplet T, int i, ElemType* e);
//1 <= i <= 3，改变 T 的第 i 元的值为 e
extern Status Put(Triplet* T, int i, ElemType e);
//如果 T 的 3 个元素按升序排列，则返回 1，否则返回 0
extern Status IsAscending(Triplet T);
//如果 T 的 3 个元素按降序排列，则返回 1，否则返回 0
extern Status IsDescending(Triplet T);
//用 e 返回指向 T 的最大元素的值
extern Status Max(Triplet T, ElemType* e);
//用 e 返回指向 T 的最小元素的值
extern Status Min(Triplet T, ElemType* e);
//打印三元组，中间以空格隔开
extern Status PrintTriplet(Triplet T);

// --------基本操作的算法描述--------

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

Status DestroyTriplet(Triplet* T)
{
	free(T); T = NULL;
	return OK;
}//DestroyTriplet

Status Get(Triplet T, int i, ElemType* e)
{
	if (i < 1 || i > 3) return ERROR;
	*e = T[i - 1];
	return OK;
}//Get

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

Status IsAscending(Triplet T)
{
	return (T[0] <= T[1]) && (T[1] <= T[2]);
}//IsAscending

Status IsDescending(Triplet T)
{
	return (T[0] >= T[1]) && (T[1] >= T[2]);
}//IsDescending

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

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

Status PrintTriplet(Triplet T)
{
	for (int i = 0; i < 3; i++)
		printf("%d ", T[i]);
	printf("\n");
	return OK;
}//PrintTriplet

三、调用示例

int main()
{
	Triplet T;
	int v1, v2, v3, e;
	v1 = v2 = v3 = 0;

	InitTriplet(&T, v1, v2, v3);
	Put(&T, 1, 12);
	Put(&T, 2, 23);
	Put(&T, 3, 34);

	Get(T, 1, &e);
	printf("Get(T,1,e): e = %d\n", e);
	printf("IsAscending(T): return %d\n", IsAscending(T));
	printf("IsDescending(T): return %d\n", IsDescending(T));

	Max(T, &e);
	printf("Max(T,e): e = %d\n", e);
	Min(T, &e);
	printf("Min(T,e): e = %d\n", e);
	PrintTriplet(T);
}

终端输出结果如下：

Get(T,1,e): e = 12
IsAscending(T): return 1
IsDescending(T): return 0
Max(T,e): e = 34
Min(T,e): e = 12
12 23 34 

---

总结

以上是三元组的基本操作的算法描述，更多数据结构的算法描述还在更新中，敬请关注作者专栏。