1.3 抽象数据类型表示和实现

抽象数据类型（abstract data type 简称ADT）：

是指一个数据模型及其定义在该数据模型上的一组操作。

和数据结构的形式定义相对应，抽象数据类型可用以下三元组表示：

（D，S，P）

其中，D是数据对象，S是D上的关系集，P是对D的基本操作集。一般抽象数据类型定义的格式：

ADT 抽象数据类型名{

数据对象：<数据对象的定义>

数据关系：<数据关系的定义>

基本操作：<基本操作的定义>

}ADT 抽象数据类型名

在形参表中，以&打头的参数即为引用参数。

例：1-6 抽象数据类型三元组的定义；

ADT Triplet{

数据对象：D={e1，e2，e3|e1，e2，e3∈ElemSet（定义了关系运算的某个集合）}

数据关系：R1={<e1，e2>，<e2，e3>}

基本操作：

   InitTriplet（&T，v1，v2，v3）

操作结果：构造了三元组T，元素e1，e2，e3，分别被赋值为v1，v2，v3的值。

 DestroyTriplet（&T）

操作结果：三元组T被销毁。

Get（T,i,&e）

操作结果：用e返回T的第i元的值。

Put（&T,i,e）

操作结果：改变T的第i元的值为e。

IsAscending（T）

操作结果：如果T的三个元素按升序排列，则返回1，否则返回0。

IsDescending（T）

操作结果：如果T的三个元素按降序排列，则返回1，否则返回0。

Max（T,&e）

操作结果：用e返回T中元素的最大值。

Min（T,&e）

操作结果：用e返回T中元素的最小值。

}ADT Triplet

例1-7 抽象数据类型Triplet的表示与实现：

预定义常量和类型

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

//Status是函数类型，其值是函数结构状态代码

typedef int Status；

//------------------采用动态分配的顺序存储结构-------------------------------------------

typedef ElemType *Triplet；//有InitTriplet分配3个元素的存储空间；

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

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

//--------------------------基本操作实现---------------------------------------------------

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

T = NULL;

return OK;

}

Status Get（Triplet T, int i, ElemType &e)

{

if(i<1 || i>3)return ERROR;

e = T[i-1];

return OK;

}

Status Put(Triplet &t, int i, ElemType e)

{

if(i<1 || i>3)return ERROR;

T[i-1] = e;

return OK;

}

   Status IsAscending(Triplet T)

{

return( T[0] <= T[1] )&&( T[1] <= T[2] );

}

Status IsDescending(Triplet T)

{

return( T[0] >= T[1] )&&( T[1] >= T[2] );

}

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;

}

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;

}