抽象数据类型Triplet的表示与实现

《数据结构》算法实现及解析

——配合严蔚敏、吴伟民编著的《数据结构》（C语言版）

1.抽象数据类型Triplet的表示与实现

#include "c1.h"

#pragma once
//c1.h程序名
#include <string.h>
#include <ctype.h>
#include <malloc.h>//malloc.h()等
#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()
#include <iostream>//cout,cin
using namespace std;

//函数结果状态代码

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//#define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3，故去掉此行
typedef int Status;//Status是函数的类型，其值是函数结果状态代码，如OK等
typedef int Boolean;//Boolean是布尔类型，其值是TRUE或FALSE

#include "c1-1.h"

#pragma once

typedef int ElemType;//定义抽象数据类型ElemType在本程序中为整型

//-----采用动态分配的顺序存储结构-----
typedef ElemType* Triplet;//由InitTriplet分配3个元素存储空间

#include "bo1-1.cpp"

//bo1-1.cpp抽象数据类型Triplet和ElemType(由c1-1.h定义)的基本操作（8个）
#include "c1.h"
#include "c1-1.h"

//-----基本操作的函数原型说明-----
inline Status InitTriplet(Triplet& T, ElemType v1, ElemType v2, ElemType v3)
{
	//操作结果：构造三元组T，依次置T的3个元素值为v1,v2,v3
	if (!(T = (ElemType*)malloc(3 * sizeof(ElemType))))
		exit(OVERFLOW);
	T[0] = v1, T[1] = v2, T[2] = v3;
	return OK;
}

inline Status DestroyTriplet(Triplet& T)
{
	//操作结果：三元组T被销毁
	free(T);
	T = NULL;
	return OK;
}

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

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

inline Status IsAscending(Triplet T)
{
	//初始条件：三元组T已存在。操作结果：如果T的3个元素按升序排列，则返回1；否则返回0
	return (T[0] <= T[1] && T[1] <= T[2]);
}

inline Status IsDescending(Triplet T)
{
	//初始条件：三元组T已存在。操作结果：如果T的3个元素按降序排列，则返回1；否则返回0
	return (T[0] >= T[1] && T[1] >= T[2]);
}

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

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

Main1-1.cpp

//Main1-1.cpp检验基本操作bo1-1.cpp的主函数
#include "c1.h"
#include "c1-1.h"
#include "bo1-1.cpp"

int main()
{
	Triplet T;
	ElemType m;
	Status i;
	i = InitTriplet(T, 5, 7, 9);//初始化三元组T，其3个元素依次为5，7，9
	printf("调用初始化函数后，i=%d(1:成功)T的3个值为", i);
	cout << T[0] << ' ' << T[1] << ' ' << T[2] << endl;
	i = Get(T, 2, m);//将三元组T的第2个值赋给m
	if (i == OK)//调用Get()成功
		cout << "T的第2个值为" << m << endl;
	i = Put(T, 2, 6);//将三元组的第2个值改为6
	if (i == OK)//调用Put()成功
		cout << "将T的第二个值改为6后，T的3个值为" << T[0] << ' ' << T[1] << ' ' << T[2] << endl;
	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)//先赋值再比较
		cout << "T中的最大值为" << m << endl;
	if((i==Min(T,m)==OK))
		cout<<"T中的最小值为"<<m<<endl;
	DestroyTriplet(T);//函数也可以不带回返回值
	cout << "销毁T后，T=" << T << "(NULL)" << endl;
	return 0;
}

变量的引用类型和非引用类型的区别

//algo1-3.cpp变量的引用类型和非引用类型的区别
#include <stdio.h>
void fa(int a)//在函数中改变a，将不会带回主调函数（主调函数中的a仍是原值）
{
	a++;
	printf("在函数fa中：a=%d\n", a);
}

void fb(int& a)//由于a为引用类型，在函数中改变a，其值将待会主调函数
{
	a++;
	printf("在函数fb中：a=%d\n", a);
}
int main()
{
	int n = 1;
	printf("在主程序中，调用函数fa之前：n=%d\n", n);
	fa(n);
	printf("在主程序中，调用函数fa之后，调用函数fb之前：n=%d\n", n);
	fb(n);
	printf("在主程序中，调用函数fb之后：n=%d\n", n);
	return 0;
}