数据结构--抽象数据类型

NNLYF_

已于 2023-09-21 22:56:20 修改

阅读量557

点赞数

文章标签：数据结构

于 2023-09-21 22:56:17 首次发布

本文链接：https://blog.csdn.net/NNLYF_/article/details/133132009

版权

数据类型可被看做由一种数据结构和定义在其上的一组操作所组成的。

抽象数据类型指一个数学模型以及定义在该模型上的一组操作。

抽象数据类型形式定义：

ADT抽象数据类型名{

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

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

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

}

例一：复数抽象数据类型（ADT）的描述

类型名称：Complex

数据对象集：一个复数，a + bi

操作集：对于任意复数x、y、z

Complex，以及正整数a、b，以下仅列出几项有代表性的操作。

1）Complex create( int a, int b )：创建一个a + bi的复数；

2）ElementType GetCompReal( Complex x)：返回复数x的实部；

3）ElementType GetCompImag( Complex x)：返回复数x的虚部；

4）void Print(Complex x )：输出复数x；

5）Complex Add( Complex x, Complex y)：求2个复数x和y的和；

6）Complex Subtract( Complex x, Complex y)：求2个复数x和y的差；

7）Complex Multiply( Complex x, Complex y)：求2个复数x和y的积；

1.#include <stdio.h>  
2.//复数类   
3.typedef struct complex{  
4.    int real,imag;  //a + bi  
5.}comp;  
6.//1.创建一个复数  
7.void create(comp *x,int real,int imag);  
8.//2.输出一个复数  
9.void print(comp x);  
10.//3.加  
11.void add(comp x,comp y,comp *z);   
12.//4.减  
13.void subtract(comp x,comp y,comp *z);   
14.//5.乘   
15.void multiply(comp x,comp y,comp *z);   
16.  
17.int main()  
18.{  
19.    //1.输入2个复数  
20.    comp x,y,z;  
21.    create(&x,1,3);  
22.    create(&y,2,-2);  
23.//  x.real = 1; x.imag = 3;  
24.//  y.real = 2; y.imag = -2;  
25.    print(x);   //输出x   
26.    print(y);   //输出y  
27.    add(x,y,&z);    //z = x + y  
28.    print(z);  
29.    subtract(x,y,&z);   //z = x - y  
30.    print(z);  
31.    multiply(x,y,&z);   //z = x * y  
32.    print(z);      
33.    return 0;  
34.}   
35.  
36.//1.创建一个复数  
37.void create(comp *x,int real,int imag)  
38.{  
39.    x -> real = real;    //结构体指针用指向运算符->   
40.    x -> imag = imag;  
41.}  
42.//2.输出一个复数  
43.void print(comp x)  
44.{  
45.    //实部不为0，就输出实部   
46.    if(x.real != 0){  
47.        //虚部不为0  
48.        if(x.imag > 0){  
49.            if(x.imag != 1)  
50.                printf("%d + %di",x.real,x.imag);   
51.            else  
52.                printf("%d + i",x.real);  
53.        }  
54.        else if(x.imag < 0){  
55.            if(x.imag != -1)  
56.                printf("%d - %di",x.real,-x.imag);   
57.            else  
58.                printf("%d - i",x.real);  
59.        }  
60.        else  
61.            printf("%d",x.real);   
62.    }  
63.    else{  
64.        //虚部不为0  
65.        if(x.imag > 0){  
66.            if(x.imag != 1)  
67.                printf("%di",x.imag);   
68.            else  
69.                printf("i");  
70.        }  
71.        else if(x.imag < 0){  
72.            if(x.imag != -1)  
73.                printf("%di",x.imag);   
74.            else  
75.                printf("-i");  
76.        }     
77.        else  
78.            printf("0");          
79.    }  
80.    printf("\n");     
81.}  
82.//3.加,实部+实部，虚部+虚部   
83.void add(comp x,comp y,comp *z)   
84.{  
85.    z -> real = x.real + y.real;  
86.    z -> imag = x.imag + y.imag;  
87.}  
88.//4.减  
89.void subtract(comp x,comp y,comp *z)   
90.{  
91.      
92.}  
93.//5.乘   
94.void multiply(comp x,comp y,comp *z)   
95.{  
96.      
97.}

例题二：矩阵抽象数据类型（ADT）的描述及实现

1、矩阵抽象数据类型（ADT）的描述

类型名称：Matrix

数据对象集：一个M*N的矩阵

操作集：对于任意矩阵A、B、C

Matrix，以及正整数i、j、M、N，以下仅列出几项有代表性的操作。

1）Matrix Create( int M, int N )：返回一个的空矩阵；

2）int GetMatRow( Matrix A )：返回矩阵A的总行数；

3）int GetMatCol( Matrix A )：返回矩阵A的总列数；

4）void Print(Matrix A )：输出矩阵A；

5）ElementType GetEntry( Matrix A, int i, int j )：返回矩阵A的第i行、第j列的元素；

6）Matrix Add( Matrix A, Matrix B )：如果A和B的行、列数一致，则返回矩阵C=A+B，否则返回错误标志；

7） Matrix Multiply( Matrix A, Matrix B )：如果A的列数等于B的行数，则返回矩阵C = AB，否则返回错误标志；

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#define N (100 + 5)
#define M (100 + 5)



typedef struct Matrix{//矩阵类型
	int m, n;// 第m行 第n列
	int a[M][N];
}Matrix;

//操作集  --函数声明

Matrix Create(int m,int n,int a[M][N]);//创建一个m行n列的矩阵

int GetMatRow(Matrix A);//返回矩阵A的总行数

int GetMatCol(Matrix A);//返回矩阵A的总列数

void Print(Matrix A);//输出矩阵A

int GetEntry(Matrix A, int i, int j);//返回矩阵A的第i行、第j列的元素；

int add(Matrix A, Matrix B, Matrix* C);//如果A和B的行、列数一致，则返回矩阵C=A+B，否则返回错误标志；

int multiply(Matrix A, Matrix B, Matrix* C);//如果A的列数等于B的行数，则返回矩阵C = AB，否则返回错误标志；

int main()
{
	//注意赋值的内部元素用的也是大括号:{}
	int a[M][N] = { {1,1,1},{2,2,2},{3,3,3} };
	int b[M][N] = { {1,2,3,4},{2,3,4,5} };

	//创建矩阵
	Matrix x, y, z;//x和y分别为第一个和第二个矩阵 z是新的矩阵

	x = Create(3, 3, a);
	y = Create(2, 4, b);
	//输出矩阵
	Print(x);
	Print(y);

	//如果A和B的行、列数一致，则返回矩阵C=A+B，否则返回0  
	if (add(x, y, &z)) {//如果是同型矩阵
		printf("输出两个矩阵的和(%d*%d):\n", z.m, z.n);
		Print(z);
	}
	else {
		printf("两个矩阵A和B不是同型矩阵，不能相加\n");
	}
	
	//如果A的列数等于B的行数，返回矩阵C  = AB，则返回0  
		if (multiply(x, y, &z)) {
			printf("输出两个矩阵的乘积(%d*%d):\n",z.m,z.n);
	}
		else {
			printf("A的列数不等于B的行数，不能相乘\n");
		}

	return 0;
}

//1.创建一个m行n列的新矩阵：
//这一步是为了将二维数组转换成矩阵便于后续计算
Matrix Create(int m, int n, int a[M][N])
{
	Matrix b;
	b.m = m;
	b.n = n;
	for (int i = 0; i < b.m; i++) {
		for (int j = 0; j < b.n; j++) {
			b.a[i][j] = a[i][j];
		}
	}
	return b;
}
//2:返回矩阵的总行数
int GetMatRow(Matrix A)
{
	return A.m;
}

//3.返回矩阵的总列数
int GetMatCol(Matrix A)

{
	return A.n;
}

//4.输出矩阵A
void Print(Matrix A)
{
	printf("输出矩阵(%d*%d):\n", A.m, A.n);
	for (int i = 0; i < A.m; i++) {
		for (int j = 0; j < A.n; j++) {
			printf("%4d ", A.a[i][j]);//结构体变量A中成员a的二维数组元素
		}
		printf("\n");
	}
}

//5.返回矩阵A的第i行、第j列的元素；
int GetEntry(Matrix A, int i, int j)

{
	return A.a[i][j];
}

//6.如果A和B的行、列数一致，则返回矩阵C=A+B，否则返回0 

int add(Matrix A, Matrix B, Matrix* C)

{
	if (A.m == B.m && A.n == B.n) {
		C->m = A.m;
		C->n = B.n;
		for (int i =0 ; i < A.m; i++) {//注意i和j是从0开始
			for(int j = 0; j < A.n; j++) {
				 C->a[i][j] = A.a[i][j] + B.a[i][j];
			}
		}
		return 1;
	}
	else {

		return 0;
	}
}
//7.如果A的列数等于B的行数，返回矩阵C = AB，则返回0  
int multiply(Matrix A, Matrix B, Matrix* C)

{
	if (A.n == B.m) {
		C->m = A.m;
		C->n = B.n;
		for (int i = 0; i < A.m; i++) {
			for (int j = 0; j < A.n; j++) {
				 C->a[i][j] = A.a[i][j] *B.a[i][j];
			}
		}
		return 1;
	}  
	else {
		return 0;
	}
}