考研数据结构之数组（5.6）——练习题之假设稀疏矩阵A和B都采用三元组表示，编写一个函数计算C=A+B，要求C也用三元组表示（C表示）

于 2020-05-26 19:53:51 发布
阅读量6.7k 收藏 72
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/106363005
版权

题目

假设稀疏矩阵A和B（两矩阵的行列数相等）都采用三元组表示，编写一个函数，计算C=A+B，要求C也采用三元组表示，所有矩阵都为int型。

分析

第一种思路是先将A和B由三元组表示转换成稀疏矩阵的表示形式，然后计算A+B=C，再将C由稀疏矩阵表示成三元组。

第二种思路是，两矩阵相加规则为对应位置上的元素相加，对于三元组存储结构下的矩阵A和B假如当前需要将位置(i, j)上的元素a[i,j]和b[i,j]相加，需要考虑三种不同的情况: a[i,j]等于0, b[i,j]不等于0; a[i,j]不等于0，b[i,j]不等于0; a[i,j]不等于0，b[i,j]等于 0。对应的可以按照以下步骤进行处理:依次遍历A和B的行号和列号，若A当前元素的行号等于B当前元素的行号，则比较其列号，将较小列的元素存入C中:如果列号也相等，则将对应的元素值相加后存入C中:若A当前元素的行号小于B当前元素的行号，则将A的元素存入C中:若A当前元素的行号大于B当前元素的行号，则将B的元素存入C中，如此这样产生了C.

代码

第一种思路：

/* 将三元组转换成稀疏矩阵 */ 
int trimatToMat(int A[][3],int mat[][MAXSIZE]){
	int m=A[0][1];// 稀疏矩阵的行数
	int n=A[0][2];// 稀疏矩阵的列数
	int k=1;// 三元组数组的下标，初始为1，因为trimat[0][0-2]保存的是三元组的一些基本信息
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) { // 双层循环遍历稀疏矩阵
			if(i==A[k][1]&&j==A[k][2]) { // 如果i和j能够匹配三元组的下标trimat[k][1]和trimat[k][2]
				mat[i][j]=A[k][0];
				k++;// 继续遍历三元组的元素
			} else {
				mat[i][j]=0;
			}
		}
	}
}

/* 矩阵的相加 */
/* C[][MAXSIZE]指的是相加的结果矩阵；A[][MAXSIZE]指要参与相加运算的矩阵；B[][MAXSIZE]指要参与相加运算的矩阵；m指的是矩阵的行数；n指的是矩阵的列数 */ 
void addmat(int C[][MAXSIZE],int A[][MAXSIZE],int B[][MAXSIZE],int m,int n){
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			C[i][j]=A[i][j]+B[i][j];// 矩阵元素的相加 
		}
	}
} 

/* 根据给定的稀疏矩阵A(int型)创建三元组存储结构 */
/* A[][MAXSIZE]指的是稀疏矩阵；m指的是稀疏矩阵的行数；n指的是稀疏矩阵的列数；trimat[][3]指的是三元组 */ 
void createTrimat(int A[][MAXSIZE],int m,int n,int trimat[][3]) {
	int k=1;// 计数器，记录三元组的行下标，从1开始，0存储稀疏矩阵的基本信息
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){// 双层嵌套循环，遍历稀疏矩阵的所有元素
			if(A[i][j]!=0){
				trimat[k][0]=A[i][j];// trimat[k][0]存储稀疏矩阵中非零元素的值
				trimat[k][1]=i;// trimat[k][1]存储稀疏矩阵中非零元素的行下标 
				trimat[k][2]=j;// trimat[k][2]存储稀疏矩阵中非零元素的列下标 
				k++;// 计数器加1 
			} 
		}
	} 
	/* 存储一些稀疏矩阵的基本信息 */
	trimat[0][0]=k-1;// 保存矩阵中非零元素的个数
	trimat[0][1]=m;// 保存矩阵的行数 
	trimat[0][2]=n;// 保存矩阵的列数 
}

/* 稀疏矩阵A和B都采用三元组表示，计算C=A+B，要求C也用三元组表示 */
addTrimat(int A[][3],int B[][3],int C[][3]){
	int matA[MAXSIZE][MAXSIZE];
	int matB[MAXSIZE][MAXSIZE];
	int matC[MAXSIZE][MAXSIZE];
	trimatToMat(A,matA);
	trimatToMat(B,matB);
	addmat(matC,matA,matB,A[0][1],A[0][2]);
	createTrimat(matC,A[0][1],A[0][2],C);
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
/* 8.稀疏矩阵A和B都采用三元组表示，计算C=A+B，要求C也用三元组表示 */
#define MAXSIZE 20

/* 将三元组转换成稀疏矩阵 */ 
int trimatToMat(int A[][3],int mat[][MAXSIZE]){
	int m=A[0][1];// 稀疏矩阵的行数
	int n=A[0][2];// 稀疏矩阵的列数
	int k=1;// 三元组数组的下标，初始为1，因为trimat[0][0-2]保存的是三元组的一些基本信息
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) { // 双层循环遍历稀疏矩阵
			if(i==A[k][1]&&j==A[k][2]) { // 如果i和j能够匹配三元组的下标trimat[k][1]和trimat[k][2]
				mat[i][j]=A[k][0];
				k++;// 继续遍历三元组的元素
			} else {
				mat[i][j]=0;
			}
		}
	}
}

/* 矩阵的相加 */
/* C[][MAXSIZE]指的是相加的结果矩阵；A[][MAXSIZE]指要参与相加运算的矩阵；B[][MAXSIZE]指要参与相加运算的矩阵；m指的是矩阵的行数；n指的是矩阵的列数 */ 
void addmat(int C[][MAXSIZE],int A[][MAXSIZE],int B[][MAXSIZE],int m,int n){
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			C[i][j]=A[i][j]+B[i][j];// 矩阵元素的相加 
		}
	}
} 

/* 根据给定的稀疏矩阵A(int型)创建三元组存储结构 */
/* A[][MAXSIZE]指的是稀疏矩阵；m指的是稀疏矩阵的行数；n指的是稀疏矩阵的列数；trimat[][3]指的是三元组 */ 
void createTrimat(int A[][MAXSIZE],int m,int n,int trimat[][3]) {
	int k=1;// 计数器，记录三元组的行下标，从1开始，0存储稀疏矩阵的基本信息
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){// 双层嵌套循环，遍历稀疏矩阵的所有元素
			if(A[i][j]!=0){
				trimat[k][0]=A[i][j];// trimat[k][0]存储稀疏矩阵中非零元素的值
				trimat[k][1]=i;// trimat[k][1]存储稀疏矩阵中非零元素的行下标 
				trimat[k][2]=j;// trimat[k][2]存储稀疏矩阵中非零元素的列下标 
				k++;// 计数器加1 
			} 
		}
	} 
	/* 存储一些稀疏矩阵的基本信息 */
	trimat[0][0]=k-1;// 保存矩阵中非零元素的个数
	trimat[0][1]=m;// 保存矩阵的行数 
	trimat[0][2]=n;// 保存矩阵的列数 
}

/* 稀疏矩阵A和B都采用三元组表示，计算C=A+B，要求C也用三元组表示 */
addTrimat(int A[][3],int B[][3],int C[][3]){
	int matA[MAXSIZE][MAXSIZE];
	int matB[MAXSIZE][MAXSIZE];
	int matC[MAXSIZE][MAXSIZE];
	trimatToMat(A,matA);
	trimatToMat(B,matB);
	addmat(matC,matA,matB,A[0][1],A[0][2]);
	createTrimat(matC,A[0][1],A[0][2],C);
}


/* 打印矩阵 */
/* A[][MAXSIZE]指的是矩阵；m指的是矩阵的行数；n指的是矩阵的列数 */
void printMat(int A[][MAXSIZE],int m,int n) {
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			printf("%d\t",A[i][j]);
		}
		printf("\n");
	}
}

/* 打印三元组 */
void print(int trimat[][3]){
	printf("\n");
	for(int k=1;k<=trimat[0][0];k++){
		printf("%d\t",trimat[k][0]);
	}
	printf("\n");
} 


int main() {

	int A[][MAXSIZE]= {
		{0,0,0,1},
		{0,0,3,2},
		{1,0,0,0},
		{0,2,0,0},
		{1,0,0,0}
	};
	int m=5,n=4;// 指的是矩阵的行数和列数
	printf("原矩阵A：\n");
	printMat(A,m,n);// 打印原矩阵

	int B[][MAXSIZE]= {
		{0,0,0,1},
		{0,0,3,2},
		{1,0,0,0},
		{0,2,0,0},
		{1,0,0,0}
	};
	printf("原矩阵B：\n");
	printMat(B,m,n);// 打印原矩阵

	int matA[MAXSIZE][3];
	createTrimat(A,m,n,matA);
	int matB[MAXSIZE][3];
	createTrimat(B,m,n,matB);
	int matC[MAXSIZE][3];
	addTrimat(matA,matB,matC);
	
	print(matC);

	return 0;
}

运行如下：

第二种思路的代码：

void add(int A[][3],int B[][3],int C[][3]) {
	int i=1,j=1,k=1,m;
	while(i<=A[0][0]&&j<=B[0][0]) {
		if(A[i][1]==B[j][1]) {
			// 若A当前元素的行号等于B当前元素的行号，则比较列号，将较小的列的元素存入C中；若列号相等，则将对应的元素值相加后存入C中
			if(A[i][2]<B[j][2]) {
				C[k][0]=A[i][0];
				C[k][1]=A[i][1];
				C[k][2]=A[i][2];
				k++;
				i++;
			} else if(A[i][2]>B[j][2]) {
				C[k][0]=B[j][0];
				C[k][1]=B[j][1];
				C[k][2]=B[j][2];
				k++;
				j++;
			} else {
				m=A[i][0]+B[j][0];
				if(m!=0) { // m有可能为0，不为0才添加到C中
					C[k][1]=B[j][1];
					C[k][2]=B[j][2];
					C[k][0]=m;
					k++;
				}
				i++;
				j++;
			}
		} else if(A[i][1]<B[j][1]) {
			// 若A当前元素的行号小于B当前元素的行号，则将A的元素存入C中
			C[k][0]=A[i][0];
			C[k][1]=A[i][1];
			C[k][2]=A[i][2];
			k++;
			i++;
		} else {
			// 若A当前元素的行号大于B当前元素的行号，则将B的元素存入C中
			C[k][0]=B[j][0];
			C[k][1]=B[j][1];
			C[k][2]=B[j][2];
			k++;
			j++;
		}
	}
	// A中有剩余元素，B已经处理完毕，将A中元素直接放入C中
	while(i<=A[0][0]) {
		C[k][0]=A[i][0];
		C[k][1]=A[i][1];
		C[k][2]=A[i][2];
		k++;
		i++;
	}
	// B中有剩余元素，A已经处理完毕，将B中元素直接放入C中
	while(j<=B[0][0]) {
		C[k][0]=B[j][0];
		C[k][1]=B[j][1];
		C[k][2]=B[j][2];
		k++;
		j++;
	}
	C[0][0]=k-1;// 产生第0行的结果
	C[0][1]=A[0][1];
	C[0][2]=A[0][2]; 
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
/* 稀疏矩阵A和B都采用三元组表示，计算C=A+B，要求C也用三元组表示 */
#define MAXSIZE 20

/* 根据给定的稀疏矩阵A(int型)创建三元组存储结构 */
/* A[][MAXSIZE]指的是稀疏矩阵；m指的是稀疏矩阵的行数；n指的是稀疏矩阵的列数；trimat[][3]指的是三元组 */
void createTrimat(int A[][MAXSIZE],int m,int n,int trimat[][3]) {
	int k=1;// 计数器，记录三元组的行下标，从1开始，0存储稀疏矩阵的基本信息
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) { // 双层嵌套循环，遍历稀疏矩阵的所有元素
			if(A[i][j]!=0) {
				trimat[k][0]=A[i][j];// trimat[k][0]存储稀疏矩阵中非零元素的值
				trimat[k][1]=i;// trimat[k][1]存储稀疏矩阵中非零元素的行下标
				trimat[k][2]=j;// trimat[k][2]存储稀疏矩阵中非零元素的列下标
				k++;// 计数器加1
			}
		}
	}
	/* 存储一些稀疏矩阵的基本信息 */
	trimat[0][0]=k-1;// 保存矩阵中非零元素的个数
	trimat[0][1]=m;// 保存矩阵的行数
	trimat[0][2]=n;// 保存矩阵的列数
}

/* 打印矩阵 */
/* A[][MAXSIZE]指的是矩阵；m指的是矩阵的行数；n指的是矩阵的列数 */
void printMat(int A[][MAXSIZE],int m,int n) {
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			printf("%d\t",A[i][j]);
		}
		printf("\n");
	}
}

/* 打印三元组 */
void print(int trimat[][3]) {
	printf("\n");
	for(int k=1; k<=trimat[0][0]; k++) {
		printf("%d\t",trimat[k][0]);
	}
	printf("\n");
}

/* 矩阵相加，相加的结果也表示为三元组 */
void add(int A[][3],int B[][3],int C[][3]) {
	int i=1,j=1,k=1,m;
	while(i<=A[0][0]&&j<=B[0][0]) {
		if(A[i][1]==B[j][1]) {
			// 若A当前元素的行号等于B当前元素的行号，则比较列号，将较小的列的元素存入C中；若列号相等，则将对应的元素值相加后存入C中
			if(A[i][2]<B[j][2]) {
				C[k][0]=A[i][0];
				C[k][1]=A[i][1];
				C[k][2]=A[i][2];
				k++;
				i++;
			} else if(A[i][2]>B[j][2]) {
				C[k][0]=B[j][0];
				C[k][1]=B[j][1];
				C[k][2]=B[j][2];
				k++;
				j++;
			} else {
				m=A[i][0]+B[j][0];
				if(m!=0) { // m有可能为0，不为0才添加到C中
					C[k][1]=B[j][1];
					C[k][2]=B[j][2];
					C[k][0]=m;
					k++;
				}
				i++;
				j++;
			}
		} else if(A[i][1]<B[j][1]) {
			// 若A当前元素的行号小于B当前元素的行号，则将A的元素存入C中
			C[k][0]=A[i][0];
			C[k][1]=A[i][1];
			C[k][2]=A[i][2];
			k++;
			i++;
		} else {
			// 若A当前元素的行号大于B当前元素的行号，则将B的元素存入C中
			C[k][0]=B[j][0];
			C[k][1]=B[j][1];
			C[k][2]=B[j][2];
			k++;
			j++;
		}
	}
	// A中有剩余元素，B已经处理完毕，将A中元素直接放入C中
	while(i<=A[0][0]) {
		C[k][0]=A[i][0];
		C[k][1]=A[i][1];
		C[k][2]=A[i][2];
		k++;
		i++;
	}
	// B中有剩余元素，A已经处理完毕，将B中元素直接放入C中
	while(j<=B[0][0]) {
		C[k][0]=B[j][0];
		C[k][1]=B[j][1];
		C[k][2]=B[j][2];
		k++;
		j++;
	}
	C[0][0]=k-1;// 产生第0行的结果
	C[0][1]=A[0][1];
	C[0][2]=A[0][2];
}


int main() {

	int A[][MAXSIZE]= {
		{0,0,0,1},
		{0,0,3,2},
		{1,0,0,0},
		{0,2,0,0},
		{1,0,0,0}
	};
	int m=5,n=4;// 指的是矩阵的行数和列数
	printf("原矩阵A：\n");
	printMat(A,m,n);// 打印原矩阵

	int B[][MAXSIZE]= {
		{0,0,0,1},
		{0,0,3,2},
		{1,0,0,0},
		{0,2,0,0},
		{1,0,0,0}
	};
	printf("原矩阵B：\n");
	printMat(B,m,n);// 打印原矩阵

	int matA[MAXSIZE][3];
	createTrimat(A,m,n,matA);
	print(matA);
	int matB[MAXSIZE][3];
	createTrimat(B,m,n,matB);
	print(matB);
	int matC[MAXSIZE][3];
	add(matA,matB,matC);
	print(matC);

	return 0;
}

运行结果如下：

二木成林
关注
  • 7
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值