数据结构 严蔚敏 清华大学出版社 第一章 抽象数据类型 三元组的实现 成功编译并运行

课本上的算法实现!

/* main.cpp 检验基本操作Functions.cpp的主函数 */
#include"MacroDef.h"  /* 要将程序中所有#include命令所包含的文件拷贝到当前目录下 */
/* 以下2行可根据需要选用一个（且只能选用一个），而不需改变基本操作Functions.cpp */
#include"ElemType.h" /* 在此命令之前要定义ElemType的类型 */
/* 抽象数据类型Triplet和ElemType的基本操作(8个) */
int main()
{
    Triplet T;//自定义数据类型
    ElemType m;
    Status i;
    i=InitTriplet(&T,5,7,9);
    /* i=InitTriplet(&T,5.0,7.1,9.3); /* 当ElemType为双精度型时,可取代上句 */
    /* 调用函数, 将返回值存在i中, 通过后面的printf语句来判断是否成功! */

    printf("调用初始化函数后，i=%d(1:成功) T的三个值为：%d %d %d\n",i,T[0],T[1],T[2]);
    /* 当ElemType的类型变化时，要相应改变printf()的格式符。 */
    /* 这种测试函数的方法值得借鉴 */

    i=Get(T,2,&m);
    if(i==OK)
        printf("T的第2个值为：%d\n",m);
    i=Put(T,2,6);
    if(i==OK)
        printf("将T的第2个值改为6后，T的三个值为：%d %d %d\n",T[0],T[1],T[2]);
    i=IsAscending(T); /* 此类函数实参与ElemType的类型无关,当ElemType的类型变化时,实参不需改变 */
    printf("调用测试升序的函数后，i=%d(0:否 1:是)\n",i);
    i=IsDescending(T);
    printf("调用测试降序的函数后，i=%d(0:否 1:是)\n",i);
    if((i=Max(T,&m))==OK) /* 先赋值再比较 */
        printf("T中的最大值为：%d\n",m);
    if((i=Min(T,&m))==OK)
        printf("T中的最小值为：%d\n",m);
    DestroyTriplet(&T); /* 函数也可以不带回返回值 */
    printf("销毁T后，T=%u(NULL)\n",T);
}

//
// Created by Cooper on 21/10/2016.
//
/* ElementType.h 定义ElementType和函数声明  */
#ifndef CH1_ELEMTYPE_H
#define CH1_ELEMTYPE_H
/* 采用动态分配的顺序存储结构 */
typedef ElemType *Triplet; /* 由InitTriplet分配三个元素存储空间 */
/* Triplet类型是ElemType类型的指针，存放ElemType类型的地址 */
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);

#endif //CH1_ELEMTYPE_H

//
// Created by Cooper on 21/10/2016.
//
/* MacroDef.h 宏定义 */
#ifndef CH1_MACRODEF_H
#define CH1_MACRODEF_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() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int ElemType; /* 定义抽象数据类型ElemType在本程序中为整型 */

typedef int Status;/* 定义函数返回的状态值为整形 */

/*typedef double ElemType; /* 定义抽象数据类型ElemType在本程序中为双精度型 */
#define OVERFLOW -2
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

#endif //CH1_MACRODEF_H

//
// Created by Cooper on 21/10/2016.
//
/* Functions.cpp 函数的定义 */
#include"MacroDef.h"  /* 要将程序中所有#include命令所包含的文件拷贝到当前目录下 */
/* 以下2行可根据需要选用一个（且只能选用一个），而不需改变基本操作Functions.cpp */
#include"ElemType.h" /* 在此命令之前要定义ElemType的类型 */
/* 抽象数据类型Triplet和ElemType的基本操作(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;//将指针赋值为空
   return OK;
 }

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

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

 Status IsAscending(Triplet T)
 { /* 初始条件：三元组T已存在。操作结果：如果T的三个元素按升序排列，返回1，否则返回0 */
   return(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]);
 }

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