数据结构：抽象数据类型的表示与实现

内容：数据结构第一章算法C语言代码实现
参考书：数据结构严书，高一凡数据结构与算法
测试软件：Visual Studio 2017

c1.h:

#ifndef __C1_H
//#define __C1_H

//c1.h(头文件名)
#include <string.h>     //字符串函数头文件
#include <ctype.h>      //字符函数头文件
#include <malloc.h>     //malloc()等
#include <limits.h>     //INT_MAX等
#include <stdio.h>      //标准输入输出头文件，包括EOF( = ^Z 或F6)，NULL等
#include <stdlib.h>     //atoi(), exit()
#include <io.h>         //eof()
#include <math.h>       //数学函数头文件，包括floor(), ceil(), abs()等
#include <sys/timeb.h>  //ftime()
#include <stdarg.h>   //提供宏va_start, va_arg, va_end，用于存取变长参数表
//函数结果状态代码。在严书第十页
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
//#define INFESIBLE -1
//#define OVERFLOW -2   因为在math.h中已定义OVERFLOW的值为3，故去掉此行
typedef int Status; //Status是函数的；类型其值是函数结果状态代码，如OK等
typedef int Boolean; //Boolean是布尔类型，其值是TRUE或FALSE，第7、8、9章用到
typedef int ElemType;


#endif // !__C1_H
#pragma once

bo1.h:

#ifndef BO1-1_H
//#define BO1-1_h

#include "c1.h"
#include "c1-1.h"

//bo1-1.h抽象数据类型Triplet和ELemType（由c1-1.h定义）的基本操作（8个）
Status InitTriplet(Triplet &T, ElemType v1, ElemType v2, ElemType v3)
{
	//操作结果：构造三元组T，一次置T的三个元素的初值为v1,v2,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)
{
	//操作结果：三元组T被销毁
	free(T);   //释放T所指的三元组存储空间
	T = NULL;  //T不再指向任何存储单元
	return OK;
}
Status Get(Triplet T, int i, ElemType &e)
{
	//初始条件：三元组T已存在，1<=i<=3。操作结果：改变T的第i元的值为e。
	if (i < 1 || i > 3) //i不在三元组的范围之内
		return ERROR;
	e = T[i - 1];  //将三元组T的第i个元素的值赋给e
	return OK;
}
Status Put(Triplet T, int i, ElemType e)
{
	//初始条件：三元组T已存在，1<=i<=3。操作结果：改变T的第i元的值为e。
	if (i < 1 || i > 3) //i不在三元组的范围之内
		return ERROR;
	T[i - 1] = e;  //将e的值赋给三元组T的第i个元素
	return OK;
}
Status IsAscending(Triplet T)
{
	//初始条件：三元组T已存在。操作结果：如果T的三个元素按升序排列，则返回1；否则返回0
	return (T[0] <= T[1] && T[1] <= T[2]);  //只在T[0]不大于T[1]且T[1]不大于T[2]时返回真
}
Status IsDescending(Triplet T)
{
	//初始条件：三元组T已存在。操作结果：如果T的三个元素按降序排列，则返回1；否则返回0
	return (T[0] >= T[1] && T[1] >= T[2]);  //只在T[0]不小于T[1]且T[1]不小于T[2]时返回真
}
Status Max(Triplet T, ElemType &e)
{
	//三元组T已存在。操作结果：用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)
{
	//三元组T已存在。操作结果：用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; //上行是嵌套的条件运算符
}
#endif // !BO1-1_H
#pragma once

func-1.h:

#ifndef FUNC-1_H
//#define FUNC-1_H

#include "c1.h"
#include "c1-1.h"

void PrintE(ElemType e)  //输出元素的值
{
	printf("%d\n", e);  //输出整型
	//printf("%f\n", e); //输出浮点型
}
void PrintT(Triplet T)
{
	printf("%d, %d, %d\n", T[0], T[1], T[2]);
	//printf("%f, %f, %f\n", T[0], T[1], T[2]);
}
#endif // !FUN-1_H
#pragma once

c1-1.h:

#ifndef C1-1_H
//#define C1-1_H

#include "c1.h"
//c1-1.h采用动态分配的顺序存储结构。
typedef ElemType * Triplet;  //由InitTriplet分配3个元素存储空间
//Triplet 类型是ElemType类型的指针，存放ElemType类型的地址
#endif // !C1-1_H
#pragma once

main1.h:

// 抽象数据类型的表示与实现.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "c1.h"
#include "c1-1.h"
#include "func1-1.h"
#include "bo1-1.h"

int main()
{
	Triplet T;
	ElemType m;
	Status i;
	i = InitTriplet(T, 5, 7, 9);
	printf("调用初始化函数后，i = %d(1, 成功)。T的3个值为", i);
	PrintT(T); //输出T的3个值
	i = Get(T, 2, m);  //将三元组T的第二个值赋给m
	if (i == OK)
	{
		printf("T的第2个值为：");
		PrintE(m);
	}
	i = Put(T, 2, 6);
	if(i == OK)
	{
		printf("将T的第2个值改为6后，T的3个值为：");
		PrintT(T);
	}
	i = IsAscending(T);
	printf("调用测试升序的函数后，i = %d（1：是 0：否）\n", i);
	i = IsDescending(T);
	printf("调用测试降序的函数后，i = %d（1：是 0：否）\n", i);
	if ((i = Max(T, m)) == OK)
	{
		printf("T中的最大值为：");
		PrintE(m);
	}
	if ((i = Min(T, m)) == OK)
	{
		printf("T中的最小值为：");
		PrintE(m);
	}
	DestroyTriplet(T); //函数也可以不带返回值
	printf("销毁T后，T= %u\n", T);
	return 0;
}