压缩矩阵的运算
数据结构实验五矩阵的压缩存储与运算学习资料

数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现;2. 掌握稀疏矩阵的加法、转置、乘法等基本运算;3. 加深对线性表的顺序存储和链式结构的理解。
第一节知识准备矩阵是由两个关系(行关系和列关系)组成的二维数组,因此对每一个关系上都可以用线性表进行处理;考虑到两个关系的先后,在存储上就有按行优先和按列优先两种存储方式,所谓按行优先,是指将矩阵的每一行看成一个元素进行存储;所谓按列优先,是指将矩阵的每一列看成一个元素进行存储;这是矩阵在计算机中用一个连续存储区域存放的一般情形,对特殊矩阵还有特殊的存储方式。
一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= (0≤i,j≤n-1 )则称为n阶对称矩阵。
对n阶对称矩阵,我们只需要存储下三角元素就可以了。
事实上对上三角矩阵(下三角部分为零)和下三角矩阵(上三角部分为零),都可以用一维数组ma[0.. ]来存储A的下三角元素(对上三角矩阵做转置存储),称ma为矩阵A的压缩存储结构,现在我们来分析以下,A和ma之间的元素对应放置关系。
问题已经转化为:已知二维矩阵A[i,j],如图5-1,我们将A用一个一维数组ma[k]来存储,它们之间存在着如图5-2所示的一一对应关系。
任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ;这里:k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之,对所有的k=0,1,2,…,n(n+1)/2-1,都能确定ma[k]中的元素在矩阵A中的位置(i,j)。
这里,i=d-1,(d是使sum= > k的最小整数),j= 。
2. 三对角矩阵在三对角矩阵中,所有的非零元素集中在以主对角线为中心的带内状区域中,除了主对角线上和直接在对角线上、下方对角线上的元素之外,所有其它的元素皆为零,见图5-3。
gpu布尔矩阵压缩算法 -回复

gpu布尔矩阵压缩算法-回复什么是GPU布尔矩阵压缩算法?在计算机科学中,布尔矩阵是一种由0和1组成的二维数组,其中1表示真值,0表示假值。
GPU布尔矩阵压缩算法是一种针对布尔矩阵的压缩方法,旨在将存储布尔矩阵所需的内存空间减少到最小化。
该算法利用GPU (Graphics Processing Unit,图形处理器)的并行计算能力,相较于传统的CPU(Central Processing Unit,中央处理器)计算,它可以更高效地进行运算。
在这篇文章中,我们将一步一步回答关于GPU布尔矩阵压缩算法的问题。
第一步:布尔矩阵是如何表示的?布尔矩阵通常使用二维数组来表示,其中每个元素要么为0,要么为1。
例如,以下是一个3x3的布尔矩阵的示例:[1, 0, 1][0, 1, 0][1, 1, 0]在传统储存方式下,需要占据9个内存位置,而对于大型布尔矩阵来说,这样的内存占用是十分巨大的。
第二步:GPU具有哪些优势?与CPU相比,GPU在并行计算方面具有极大的优势。
它拥有大量的处理单元和存储器并行处理能力,能够同时执行多个任务。
这使得GPU在处理大规模数据集和复杂计算方面具有更高的效率和速度。
第三步:如何进行GPU布尔矩阵压缩?GPU布尔矩阵压缩算法通常包括两个主要步骤:稀疏矩阵转换和压缩存储。
首先,我们将讨论稀疏矩阵转换。
稀疏矩阵转换是指将布尔矩阵转换为稀疏矩阵的过程,其中只有非零元素被保留。
在GPU中,我们可以使用稀疏矩阵的坐标列表(Coordinate List,COO)表示方法来实现这个转换。
在COO表示中,每个非零元素都由其行和列索引以及值表示。
例如,对于之前的3x3布尔矩阵示例:(0, 0, 1), (0, 2, 1), (1, 1, 1), (2, 0, 1), (2, 1, 1)这些元组表明了原始矩阵中每个非零元素在COO表示中的位置和值。
在完成稀疏矩阵转换后,接下来就是压缩存储。
GPU布尔矩阵压缩算法通常采用基于位运算的压缩方法,如位图压缩、哈夫曼编码等。
稀疏矩阵的压缩存储方法及主要运算的实现

1.实验目的:掌握稀疏矩阵的压缩存储方法及主要运算的实现。
2.实验内容与要求:设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行两个矩阵相加;⑷执行两个矩阵相乘;⑸求一个矩阵的转置矩阵。
3.数据结构设计逻辑结构:线性结构存储结构:顺序存储结构4.算法设计#include<stdio.h>#define MAXSIZE 100typedef int datatype;typedef struct{ int i,j;datatype v;}Triple;typedef struct{ Triple data[MAXSIZE+1];int rpos[MAXSIZE+1];int mu,nu,tu;}RLSMatrix;int main(){ void AddSMatrix(RLSMatrix M);void MultSMatrix(RLSMatrix M);void FastTransposeSMatrix(RLSMatrix M);RLSMatrix M;int k;printf("请输入稀疏矩阵M的行数、列数和非零元素个数:");scanf("%d%d%d",&M.mu,&M.nu,&M.tu);printf("请输入稀疏矩阵M中非零元素的行号、列号和元素的值:\n");for(k=1;k<=M.tu;k++)scanf("%d%d%d",&M.data[k].i,&M.data[k].j,&M.data[k].v);printf("请输出稀疏矩阵M中非零元素的行号、列号和元素的值:\n");for(k=1;k<=M.tu;k++){ printf("%d%3d%3d",M.data[k].i,M.data[k].j,M.data[k].v);printf("\n");}AddSMatrix(M);MultSMatrix(M);FastTransposeSMatrix(M);return 0;}void AddSMatrix(RLSMatrix M){ RLSMatrix N,R;int k,l=1,s=1;printf("请输入稀疏矩阵N的行数、列数和非零元素个数:");scanf("%d%d%d",&N.mu,&N.nu,&N.tu);printf("请输入稀疏矩阵N中非零元素的行号、列号和元素的值:\n"); for(k=1;k<=N.tu;k++)scanf("%d%d%d",&N.data[k].i,&N.data[k].j,&N.data[k].v);if(M.mu!=N.mu||M.nu!=N.nu) printf("错误\n");else{ R.mu=M.mu;R.nu=M.nu;k=1;if(M.tu*N.tu!=0){ while(k<=M.tu&&l<=N.tu){ if(M.data[k].i==N.data[l].i){ if(M.data[k].j<N.data[k].j){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}else if(M.data[k].j==N.data[l].j){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v+N.data[l].v;if(R.data[s].v!=0) s++;k++;l++;}else{ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}else if(M.data[k].i<N.data[l].i){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}else{ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}while(k<=M.tu){ R.data[s].i=M.data[k].i;R.data[s].j=M.data[k].j;R.data[s].v=M.data[k].v;k++;s++;}while(l<=N.tu){ R.data[s].i=N.data[l].i;R.data[s].j=N.data[l].j;R.data[s].v=N.data[l].v;l++;s++;}}printf("请输出稀疏矩阵M和稀疏矩阵N的和矩阵R中非零元素的行号、列号和元素的值:\n");for(k=1;k<s;k++)printf("%d%3d%3d\n",R.data[k].i,R.data[k].j,R.data[k].v);}}void MultSMatrix(RLSMatrix M){ RLSMatrix D,Q;int num1[MAXSIZE],num2[MAXSIZE],ctemp[MAXSIZE],arow,brow,ccol,p,q,tp,t; printf("请输入稀疏矩阵D的行数、列数和非零元素个数:");scanf("%d%d%d",&D.mu,&D.nu,&D.tu);printf("请输入稀疏矩阵D中非零元素的行号、列号和元素的值:\n");for(t=1;t<=D.tu;t++)scanf("%d%d%d",&D.data[t].i,&D.data[t].j,&D.data[t].v);for(ccol=1;ccol<=M.mu;ccol++)num1[ccol]=0;for(t=1;t<=M.tu;t++)num1[M.data[t].i]++;M.rpos[1]=1;for(ccol=2;ccol<=M.mu;ccol++)M.rpos[ccol]=M.rpos[ccol-1]+num1[ccol-1];for(ccol=1;ccol<=D.mu;ccol++)num2[ccol]=0;for(t=1;t<=D.tu;t++)num2[D.data[t].i]++;D.rpos[1]=1;for(ccol=2;ccol<=D.mu;ccol++)D.rpos[ccol]=D.rpos[ccol-1]+num2[ccol-1];if(M.nu!=D.mu) printf("错误\n");else{ Q.mu=M.mu;Q.nu=D.nu;Q.tu=0;if(M.tu*D.tu!=0){ for(arow=1;arow<=M.mu;arow++){ for(ccol=1;ccol<=Q.nu;ccol++)ctemp[ccol]=0;Q.rpos[arow]=Q.tu+1;if(arow<M.mu) tp=M.rpos[arow+1];else tp=M.tu+1;for(p=M.rpos[arow];p<tp;p++){ brow=M.data[p].j;if(brow<D.mu) t=D.rpos[brow+1];else t=D.tu+1;for(q=D.rpos[brow];q<t;q++){ ccol=D.data[q].j;ctemp[ccol]+=M.data[p].v*D.data[q].v;}}for(ccol=1;ccol<=Q.nu;ccol++)if(ctemp[ccol]!=0){ if(++Q.tu>MAXSIZE) printf("错误\n");else{ Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;Q.data[Q.tu].v=ctemp[ccol];}}}}}printf("请输出稀疏矩阵M和稀疏矩阵D的乘积矩阵Q中非零元素的行号、列号和元素的值:\n");for(ccol=1;ccol<=Q.tu;ccol++)printf("%d%3d%3d\n",Q.data[ccol].i,Q.data[ccol].j,Q.data[ccol].v);}void FastTransposeSMatrix(RLSMatrix M){ RLSMatrix T;int num[MAXSIZE],cpot[MAXSIZE],col,p,q,t;T.mu=M.mu;T.nu=M.nu;T.tu=M.tu;if(T.tu!=0){ for(col=1;col<=M.mu;col++)num[col]=0;for(t=1;t<=M.tu;t++)num[M.data[t].j]++;cpot[1]=1;for(col=2;col<=M.nu;col++)cpot[col]=cpot[col-1]+num[col-1];for(p=1;p<=M.tu;p++){ col=M.data[p].j;q=cpot[col];T.data[q].i=M.data[p].j;T.data[q].j=M.data[p].i;T.data[q].v=M.data[p].v;cpot[col]++;}}printf("请输出将稀疏矩阵M转置后的稀疏矩阵T中非零元素的行号、列号和元素的值:\n");for(col=1;col<=T.tu;col++)printf("%d%3d%3d\n",T.data[col].i,T.data[col].j,T.data[col].v);}。
第4章专题3矩阵的压缩存储

三元组表=( (0,0,15), (1,1,11), (2,3,6), (4,0,9) ) 如何存储三元组表?
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表 采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
A=
0 0
0 0 a43 a44 a45 0 0 0 a54 a55
(a) 三对角矩阵
按行 存储
元素aij在一维数组中的序号
=2 + 3(i-2)+( j-i + 2) =2i+ j -2 ∵一维数组下标从0开始
∴元素aij在一维数组中的下标
= 2i+ j -3
(b) 寻址的计算方法
0 1 2 3 4 5 6 7 8 9 10 11 12
0 0
0 0
6 0
0 0
0 0
91 0 0 0 0 0
三元组顺序表是否 需要预留存储空间?
稀疏矩阵的修改操作
三元组顺序表的插入/删除操作
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
稀疏矩阵的压缩存储——三元组顺序表
采用顺序存储结构存储三元组表
15 0 0 22 0 -15
0 11 3 0 0 0
上三角中的元素aij(i<j),因为aij=aji,则访问和 它对应的元素aji即可,即:k=j×(j+1)/2+i -1 。
清华大学出版社
数据结构(C++版)第2版
4.3 矩阵的压缩存储
特殊矩阵的压缩存储——三角矩阵
使用奇异值分解进行矩阵压缩的方法探讨(五)

奇异值分解(Singular Value Decomposition,SVD)是一种常用的矩阵分解方法,它在数据压缩和噪音过滤等领域有着广泛的应用。
在本文中,我将探讨使用奇异值分解进行矩阵压缩的方法,包括其原理、实现步骤以及应用场景。
奇异值分解是一种将一个矩阵分解为三个矩阵的方法,即将一个矩阵A分解为U、Σ和V的乘积,其中U和V是正交矩阵,Σ是对角矩阵。
在奇异值分解中,U和V代表了A的左奇异向量和右奇异向量,Σ则包含了A的奇异值。
奇异值分解的原理是将原始矩阵A映射到一个更低维的空间中,从而实现数据的压缩和降维。
实现奇异值分解的步骤主要包括以下几个步骤:首先,对原始矩阵A进行对称正交化处理,得到对称矩阵B。
然后,对矩阵B进行特征值分解,得到特征值和特征向量。
接下来,根据特征值和特征向量构建对角矩阵Σ和正交矩阵U和V。
最后,将U、Σ和V相乘,即可得到原始矩阵A的奇异值分解。
奇异值分解可以被广泛用于数据压缩和噪音过滤等领域。
在数据压缩方面,奇异值分解可以将原始矩阵A映射到一个更低维的空间中,从而实现对数据的压缩。
这种压缩方法在图像处理和语音识别等领域有着重要的应用,能够减小数据的存储空间和传输带宽。
另外,在噪音过滤方面,奇异值分解可以通过保留较大的奇异值,实现对数据中噪音的过滤,提高数据的质量和准确性。
除了数据压缩和噪音过滤,奇异值分解还可以应用于推荐系统和模式识别等领域。
在推荐系统中,奇异值分解可以通过对用户-物品评分矩阵进行分解,实现对用户的个性化推荐。
在模式识别中,奇异值分解可以通过对特征矩阵进行分解,实现对模式的识别和分类。
总之,奇异值分解是一种重要的矩阵分解方法,它在数据压缩、噪音过滤、推荐系统和模式识别等领域有着广泛的应用。
通过对奇异值分解的原理、实现步骤和应用场景进行探讨,可以更好地理解和应用这一方法,从而实现对数据的有效处理和利用。
矩阵压缩存储

矩阵压缩存储矩阵压缩存储是一种将矩阵中的数据进行压缩存储的方法,可以大大减小矩阵所占用的存储空间,提高数据存储和传输的效率。
矩阵压缩存储的实现方式有很多种,其中比较常见的有行压缩存储和列压缩存储。
行压缩存储是将矩阵中的每一行数据进行压缩存储,对于每一行数据,只存储其中非零元素的值和它们在该行中的位置。
这种方式适用于矩阵中非零元素比较稀疏的情况,可以大大减小存储空间。
例如,对于一个5*5的矩阵:1 0 0 0 00 2 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5使用行压缩存储方式,可以将其压缩为:1 12 23 34 4 51 2 2 3 4 5其中第一行表示非零元素的值,第二行表示它们在该行中的位置。
列压缩存储是将矩阵中的每一列数据进行压缩存储,对于每一列数据,只存储其中非零元素的值和它们在该列中的位置。
这种方式适用于矩阵中非零元素比较密集的情况,可以大大减小存储空间。
例如,对于同样的5*5的矩阵:1 0 0 0 00 2 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5使用列压缩存储方式,可以将其压缩为:1 2 3 4 51 2 3 4 51 2 3 4 51 2 4 51 5其中第一行表示非零元素的值,第二行表示它们在该列中的位置。
矩阵压缩存储的优点在于可以大大减小存储空间,提高数据存储和传输的效率。
但是,它也存在一些缺点。
首先,对于非零元素比较密集的矩阵,行压缩存储的效果不如列压缩存储,反之亦然。
其次,矩阵压缩存储需要进行解压缩操作才能得到原始数据,这会增加一定的计算量和时间成本。
最后,矩阵压缩存储的实现需要考虑到数据的稀疏性和分布情况,否则可能会导致存储空间的浪费或者解压缩效率的降低。
总之,矩阵压缩存储是一种非常实用的数据存储和传输方式,可以大大提高数据处理的效率和速度。
在实际应用中,需要根据具体情况选择合适的压缩方式,并进行适当的优化和调整,以达到最佳的效果。
对角矩阵压缩算法

对⾓矩阵压缩算法
对⾓矩阵压缩算法
以44对⾓矩阵为例⼦
⾸先我们得知道对⾓矩阵的概念对⾓矩阵(diagonal matrix)是⼀个主对⾓线之外的元素皆为0的矩阵,常写为diag(a1,a2,...,an) 。
对⾓矩阵可以认为是矩阵中最简单的⼀种,值得⼀提的是:对⾓线上的元素可以为 0 或其他值,对⾓线上元素相等的对⾓矩阵称为数量矩阵;对⾓线上元素全为1的对⾓矩阵称为单位矩阵—来⾃百度百科。
⽐如 1 2 0 0
5 4 3 0
0 1 2 3
0 0 2 3
我们可以发现三对⾓矩阵⾸⾏和尾⾏分别有2个⾮0元素,其余⾏都是3个⾮0元素
推⼴⾄在有n ⾏的情况⾮0 元素 3(n-2)+4=3n-2
推算下标k值
对数组a【i】【j】分配⾄对⾓矩阵前i⾏中有(i-1)3+2根据对⾓线推元素位⼦得不是i-j+1就是j-i+1所以k=(i-1)3+2+j-i+1=i2+j
所以我们可以⽤k的值来推算i,j i=(k+1)/3
J=k-2*i;
得出k于i,j的关系后便可以将矩阵进⾏压缩从⽽避免了0元素的空间占⽤,直接将矩阵压缩。
使用奇异值分解进行矩阵压缩的方法探讨(九)

奇异值分解(Singular Value Decomposition,SVD)是一种常用的数学方法,广泛应用于信号处理、图像压缩、数据降维等领域。
本文将探讨使用奇异值分解进行矩阵压缩的方法,以及其在实际应用中的一些特点和局限性。
奇异值分解是一种将矩阵分解为三个矩阵乘积的方法,即A=UΣV^T,其中A是一个m×n的矩阵,U是一个m×m的正交矩阵,Σ是一个m×n的对角矩阵,V^T 是一个n×n的正交矩阵。
在奇异值分解中,U和V被称为左奇异向量和右奇异向量,Σ的对角元素被称为奇异值。
在矩阵压缩中,我们可以利用奇异值分解将原始矩阵A分解为三个矩阵的乘积。
然后,我们可以通过保留奇异值较大的部分,来近似表示原始矩阵。
这样做的好处在于可以用较小的存储空间来表示原始矩阵,从而实现矩阵的压缩。
值得注意的是,奇异值分解的压缩效果取决于保留的奇异值个数。
通常情况下,我们可以根据奇异值的大小来决定保留的奇异值个数,从而实现不同程度的矩阵压缩。
在实际应用中,我们可以通过调整保留的奇异值个数来平衡压缩后的矩阵表示和压缩比之间的关系。
另外,奇异值分解在图像压缩中也有着重要的应用。
通过对图像矩阵进行奇异值分解,我们可以将图像表示为奇异值较少的近似矩阵,从而实现对图像的压缩。
这种方法在图像传输和存储中具有重要的意义,可以有效减小图像文件的大小,节省存储空间和传输带宽。
然而,奇异值分解也存在一些局限性。
首先,对于大规模矩阵的奇异值分解计算量较大,需要耗费大量的时间和计算资源。
其次,在实际应用中,由于保留奇异值个数的选择较为主观,可能会影响压缩后矩阵的表示效果。
因此,如何在实际应用中选择合适的奇异值个数,以及如何在保证表示效果的同时实现较高的压缩比,仍然是一个具有挑战性的问题。
综上所述,奇异值分解是一种重要的矩阵压缩方法,具有广泛的应用前景。
通过奇异值分解,我们可以实现对矩阵的压缩和近似表示,从而在存储和传输方面带来一系列的好处。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
for (m=T->elem_num-1;m>i-1;m--) { if (T->arry[m].h_num<T->arry[m-1].h_num)
void transpose_TS(TSMatrix *T);
void equal_Triple(Triple *t1,Triple *t2);
Rect.cpp
#include <stdio.h> #include <stdlib.h> #include "rect.h"
void Init_TS(TSMatrix *T) {
T->arry[n].h_num=T2->arry[j].h_num; T->arry[n].v_num=T2->arry[j].v_num; j++; n++; } } if (i>=T1->elem_num) { for (int m=j;m<T2->elem_num;m++) {
T->arry[n].elem=T2->arry[m].elem; T->arry[n].h_num=T2->arry[m].h_num; T->arry[n].v_num=T2->arry[m].v_num; n++; } } if (j>=T2->elem_num) { for (int m=i;m<T1->elem_num;m++) { T->arry[n].elem=T1->arry[m].elem; T->arry[n].h_num=T1->arry[m].h_num; T->arry[n].v_num=T1->arry[m].v_num; n++; } } T->elem_num=n;
{ equal_Triple(&W,&T->arry[m]); equal_Triple( &T->arry[m],&T->arry[m-1]); equal_Triple(&T->arry[m-1],&W);
} if (T->arry[m].h_num==T->arry[m-1].h_num) { if (T->arry[m].v_num<T->arry[m-1].v_num) { equal_Triple(&W,&T->arry[m]); equal_Triple(&T->arry[m],&T->arry[m-1]); equal_Triple(&T->arry[m-1],&W); }
T->arry=(Triple *)malloc(MAXSIZE*sizeof(Triple)); if(!T->arry) printf("error\n") ; T->elem_num=0; T->h_i=0; T->v_j=0; }
void Init_Tr(Triple *t) {
t->elem=0; t->h_num=0; t->v_num=0; }
void creat(TSMatrix *T);
void Print_TS(TSMatrix *);
void sum_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T);
void mul_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T);
if (T2->arry[k].h_num==T1->arry[i].v_num) {
T->arry[n].elem=T1->arry[i].elem*T2->arry[k].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T2->arry[k].v_num;
scanf("%d %d %d",&T->arry[i].h_num,&T->arry[i].v_num,&T->arry[i].elem); } };
void Print_TS(TSMatrix *T) {
printf("输出稀疏数组的信息\n"); printf("行下标列下标元素值\n"); for(int i=0;i<T->elem_num;i++) {
实验四 数组的运算
实验目的: 掌握稀疏矩阵的压缩存储方法及主要运算的实现。
实验内容与要求: 设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行
两个矩阵相加;⑷执行两个矩阵相乘;⑸求一个矩阵的转置矩阵;⑹求一个矩阵的逆矩阵(选 做)。 实验代码:
Rect.h
#define MAXSIZE 100
typedef struct {
int h_num; int v_num; int elem; }Triple;
typedef struct {
Triple *arry; int h_i; int v_j; int elem_num; }TSMatrix; void Init_TS(TSMatrix *T );
};
void mul_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T) {
int i=0,j=T1->arry[0].h_num,k,n=0; while (i<T1->elem_num) {
while(j==T1->arry[i].h_num) {
for (k=0;k<T2->elem_num;k++) {
void creat(TSMatrix *T) {
printf("要输入的数组的行数和列数\n"); scanf("%d,%d",&T->h_i,&T->v_j); printf("要输入稀疏数组的元素个数\n"); scanf("%d",&T->elem_num); printf("输入要输入的稀疏数组的信息\n"); printf("行值列值元素值\n"); for(int i=0;i<T->elem_num;i++) {
} }
}
};
void equal_Triple(Triple *t1,Triple *t2) {
t1-&;h_num=t2->h_num; t1->v_num=t2->v_num; };
main.cpp
#include <stdio.h> #include <stdlib.h> #include "rect.h"
n++; } } i++; } j=T1->arry[i].h_num; } T->elem_num=n; T->h_i=T2->v_j; T->v_j=T1->h_i;
};
void transpose_TS(TSMatrix *T) {
int i; int m,n; Triple W; Init_Tr(&W); for (i=0;i<T->elem_num;i++) {
printf("%d %d %d\n",T->arry[i].h_num,T->arry[i].v_num,T->arry[i].elem); } };
void sum_TS(TSMatrix *T1,TSMatrix *T2,TSMatrix *T) {
T->h_i=T1->h_i;T->v_j=T1->v_j;
int j=0,i=0; int n=0; while(i<T1->elem_num&&j<T2->elem_num) {
if (T1->arry[i].h_num==T2->arry[j].h_num) {
if (T1->arry[i].v_num==T2->arry[j].v_num) {
T->arry[n].elem=T1->arry[i].elem+T2->arry[j].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; n++; i++; j++; } else if (T1->arry[i].v_num>T2->arry[j].v_num) { T->arry[n].elem=T2->arry[j].elem; T->arry[n].h_num=T2->arry[j].h_num; T->arry[n].v_num=T2->arry[j].v_num; j++; n++; } else if (T1->arry[i].v_num<T2->arry[j].v_num) { T->arry[n].elem=T1->arry[i].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; i++; n++; } } else if (T1->arry[i].h_num<T2->arry[j].h_num) { T->arry[n].elem=T1->arry[i].elem; T->arry[n].h_num=T1->arry[i].h_num; T->arry[n].v_num=T1->arry[i].v_num; i++; n++; } else if (T1->arry[i].h_num>T2->arry[j].h_num) { T->arry[n].elem=T2->arry[j].elem;