数据结构实验稀疏矩阵计算器

实习4、稀疏矩阵运算器一、需求分析1. 问题描述稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

2. 基本要求以带“行逻辑连接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵的相加、相减和相乘运算。

稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。

3. 实现提示(1)首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否匹配。

可设聚矩阵的行数和列数不超过20。

(2)程序可以对三元组的输入顺序加以限制，例如，按行优先。

注意研究教科书5.3.2节中的算法，以便提高计算效率。

(3)在用三元组表示稀疏矩阵时，相加或者相减所得的结果矩阵应该另生成，乘积矩阵也可以用二维数组存放。

二、概要设计ADT SparseMatrix{数据对象：D={a ij |i=1,2,3……m;j = 1,2,3……n;a i,j ∈intSet,m 和n 分别称为矩阵的行数和列数}数据关系：R ={ Row,col}Row ={<a i,j ,a i,j+1>|1≤i ≤m ，1≤j ≤n-1}Col = {< a i,j ,a i,j+1>|1≤i ≤m-1，1≤j ≤n}基本操作：CreateSMatrix(*T);操作结果：创建稀疏矩阵T 。

AddRLSMatrix(M,N,*Q);初始条件：稀疏矩阵M 和N 的行数列数对应相等。

操作结果：求稀疏矩阵的和Q=M+N 。

SubRLSSMatrix(M,N,*Q);初始条件：稀疏矩阵M 和N 的行数列数对应相等。

操作结果：求稀疏矩阵的差Q=M-N 。

SMatrixrpos(*T)初始条件：稀疏矩阵T 存在。

操作结果：求稀疏矩阵的各行第一个非零元的位置表。

MulTSMatrix(M,N,*Q);初始条件：稀疏矩阵M 的列数与N 的行数对应相等。

数据结构课程设计五····题目：严蔚敏习题实习4第1个：实现一个能进行基本稀疏矩阵运算的运算器一、需求分析1、本程序实现一个基本稀疏矩阵的简单运算，包括加、减、乘。

2、执行操作前应先创造要进行运算的两个矩阵，然后再选择进行相应的操作。

3、以三元组顺序表表示稀疏矩阵，实现二个矩阵相加，相减，相乘的运算；稀疏矩阵的输入形式为三元组表示，运算结果则为通常的阵列形式列出！4、首先输入矩阵的行数和列数，并判别给出的两个矩阵和行、列数对于所要求作的运算是否相匹配。

可设矩阵的行数和列数均不超过20；5、程序先给出了菜单项，用户只需按照菜单提示进行相应的操作就行了。

6、测试数据：二、概要设计1、抽象数据类型三元组的定义如下：ADT Triple{数据对象：D={ai| ai(-ElemSet,i=1,2,...,n,n>=0};数据关系：R1={<ai-1,ai>| ai-1,ai(- D,i=2,...,n}基本操作：略}2、基于三元组顺序表表示的矩阵操作：（1）创建三元组顺序表表示的矩阵：void createMatrix(TSMatrix &A)（2）初始化矩阵：void initMatrix(TSMatrix &A)（3）相加：void add(TSMatrix A,TSMatrix B,TSMatrix &C)（4）相减：void sub(TSMatrix A,TSMatrix &B,TSMatrix &C)（5）找m行n列元素在A中顺序表中的位置：int search(TSMatrix A,int m,int n)（6）相乘；void mult(TSMatrix A,TSMatrix B,TSMatrix &C) （7）输入以阵列形式表示的矩阵：void print(TSMatrix A) 3、主程序Void main(){While(true){调用相应函数执行相应操作；输出操作结果；}}4、本程序只有两个模块，调用关系简单：三、详细设计1、三元组结构描述：#define MAXSIZE 20using namespace std;typedef struct{int row;int col;int e;}Triple;typedef struct{Triple date[MAXSIZE];int m,n,len;}TSMatrix;void initMatrix(TSMatrix &A){A.len=0;A.m=0;for(int i=0;i<MAXSIZE;i++){A.date[i].col=0;A.date[i].e=0;A.date[i].row=0;}}2、各种操作函数源代码：void createMatrix(TSMatrix &A){initMatrix(A);cout<<"创建矩阵:";cout<<"请输入矩阵的行列值及非0元素个数\n";cin>>A.m>>A.n>>A.len;for(int i=0;i<A.len;i++){cout<<"请输入第"<<i<<"个非0元素对应的行、列、值:";cin>>A.date[i].row;cin>>A.date[i].col;cin>>A.date[i].e;}}void add(TSMatrix A,TSMatrix B,TSMatrix &C)//相加{if(A.m==B.m&&A.n==B.n){int i=0,j=0;int k=0;C.m=A.m;C.n=A.n;while( i<A.len||j<B.len){if(i==A.len&&j<B.len){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(i<A.len&&j==B.len)C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}else{if(A.date[i].row>B.date[j].row){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(A.date[i].row<B.date[j].row){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}else{if(A.date[i].col==B.date[j].col){if(A.date[i].e+B.date[j].e!=0){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e+B.date[j].e;C.len++;}i++;j++;}else if(A.date[i].col>B.date[j].col){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(A.date[i].col<B.date[j].col){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}}}}}else{cout<<"不能相加！";}}void sub(TSMatrix A,TSMatrix &B,TSMatrix &C)//相减{for(int k=0;k<B.len;k++){B.date[k].e=-B.date[k].e;}if(A.m==B.m&&A.n==B.n){add(A,B,C);}elsecout<<"不能相减！";for( k=0;k<B.len;k++){B.date[k].e=-B.date[k].e;}}int search(TSMatrix A,int m,int n){int flag=-1;for(int i=0;i<MAXSIZE;i++){if(A.date[i].row==m&&A.date[i].col==n){flag=i;break;}}return flag;}void mult(TSMatrix A,TSMatrix B,TSMatrix &C)//相乘{int i=0,j=0;if(A.n==B.m){C.m=A.m;C.n=B.n;for(i=0;i<A.len;i++){for(j=0;j<B.len;j++){if(A.date[i].col==B.date[j].row){int flag=search(C,A.date[i].row,B.date[j].col);if(flag==-1){C.date[C.len].col=B.date[j].col;C.date[C.len].row=A.date[i].row;C.date[C.len++].e=A.date[i].e*B.date[j].e;}else{C.date[flag].e=C.date[flag].e+A.date[i].e*B.date[j].e;}}}}}else{cout<<"不能相乘！"<<endl;}}void print(TSMatrix A){int k=0;int i,j;int M[MAXSIZE][MAXSIZE];for(i=0;i<A.m;i++){for(j=0;j<A.n;j++){M[i][j]=0;}}while(k<A.len){M[A.date[k].row-1][A.date[k].col-1]=A.date[k].e;k++;}for(i=0;i<A.m;i++){cout<<"| ";for(j=0;j<A.n;j++){cout<<M[i][j]<<" ";}cout<<"|"<<endl;}}void showtip(){cout<<"------------请选择要执行的操作--------"<<endl;cout<<endl;cout<<" 0---创建矩阵"<<endl;cout<<" 1---A+B"<<endl;cout<<" 2---A-B"<<endl;cout<<" 3---A*B"<<endl;cout<<" 4---退出"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;}3、主函数：void main(){TSMatrix A,B,C;initMatrix(A);initMatrix(B);initMatrix(C);showtip();int i;cin>>i;while(true){switch(i){case 0:system("cls");cout<<"创建矩阵A："<<endl;createMatrix(A);cout<<"创建矩阵B："<<endl;createMatrix(B);showtip();break;case 1:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl;}else{initMatrix(C);add(A,B,C);if(A.m==B.m&&A.n==B.n){cout<<"加的结果；"<<endl;print(A);cout<<"+"<<endl;;print(B);cout<<"="<<endl;print(C);}}break;case 2:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl;}else{initMatrix(C);sub(A,B,C);cout<<"减的结果；"<<endl;print(A);cout<<"+"<<endl;;print(B);cout<<"="<<endl;print(C);}showtip();break;case 3:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl;}else{initMatrix(C);mult(A,B,C);if(A.n==B.m){cout<<"乘后的结果；"<<endl;print(A);cout<<"*"<<endl;print(B);cout<<"="<<endl;print(C);}}showtip();break;case 4:break;}cin>>i;}}四、调试分析1、由于本程序涉及的函数比较多，所以开始时在函数调用上出现了混乱，把自己都给搞糊涂了，后来经仔细排查，最终发现了错误。

数据结构实验报告数组和广义表题目：稀疏矩阵运算器物联网1班 1405891陈世超 140515411 2015.11.8一、需求分析稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

要求以带“行逻辑链接信息”的三元组顺序表存储稀疏矩阵，实现两矩阵的相加、相减、相乘等运算。

输入以三元组表示，输出以通常的阵列形式列出。

二、概要设计1、抽象数据类型定义ADT Array {数据对象:D = {aij | 0≤i≤b1-1, 0 ≤j≤b2-1}数据关系:R = { ROW, COL }ROW = {<ai,j,ai+1,j>| 0≤i≤b1-2, 0≤j≤b2-1}COL = {<ai,j,ai,j+1>| 0≤i≤b1-1, 0≤ j≤b2-2}基本操作：CreateSMatrix(&M);//操作结果:创建稀疏矩阵M. Print SMatrix(M);//初始化条件: 稀疏矩阵M存在AddSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的和Q=M+N.SubSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的差Q=M-N.MultSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M的列数等于N的行数.//操作结果:求稀疏矩阵的乘积Q=M*N.2、本程序包含四个模块1）主程序模块Void main(){初始化Do{接受命令；处理命令；}while(命令！=“退出”)}2）模块调用关系图主程序模块↓创建稀疏矩阵模块↓运算稀疏矩阵模块三、详细设计#define MAXSIZE 20#define MAXRC 10#include<iostream>using namespace std;typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int rpos[MAXRC+1];int mu,nu,tu;//mu是行，nu是列，tu是非零元个数}Matrix;void creatematrix(Matrix& M){int m,n,t,e;int num[MAXSIZE+1];//每行非零元素个数do{cout<<"输入矩阵的行数，列数和非零元数："<<endl;cout<<"矩阵行数：";cin>>m;cout<<"矩阵列数：";cin>>n;cout<<"非零元个数：";cin>>t;if(m<0||n<0||t<0||t>m*n)cout<<"error";}while(m<0||n<0||t<0||t>m*n);//检测输入是否合法M.mu = m, M.nu = n, M.tu = t;//保存数据int i,j,k,a;int flag[MAXSIZE][MAXSIZE];//标记数组：此位置是否已经有非零元素for(i=0;i<MAXSIZE;i++) //标记数组的初始化for(j=0;j<MAXSIZE;j++)flag[i][j]=0;for(k=1;k<=t;k++){do{cout<<"输入第"<<k<<"个非零元（共"<<t<<"个）的行数,列数和非零元："<<endl;cin>>i>>j>>e;if(i<=0||i>m||j<=0||j>n)cout<<"error"<<endl;if(flag[i][j]!=0){cout<<"重复！"<<endl;flag[i][j]=2;}if(e==0)cout<<"error"<<endl;}while(i<=0||i>m||j<=0||j>n||flag[i][j]==2||e==0);//检测输入是否合法for(a=1;a<=k-1&&(i>M.data[a].i||(i==M.data[a].i&&j>M.data[a].j)); a++);//找到此三元组插入的位置for(int b=k-1;b>=a;b--)M.data[b+1]=M.data[b];//行序比它大的三元组依次向后移动M.data[a].i=i;//保存数据M.data[a].j=j;//保存数据M.data[a].e=e;//保存数据}for(i=1;i<=M.mu;i++)num[i]=0;for(t=1;t<=M.tu;t++)num[M.data[t].i]++;//求M中每一行含非零元素个数M.rpos[1]=1;for(i=2;i<=M.mu;i++)M.rpos[i]=M.rpos[i-1]+num[i-1];}void printmatrix(Matrix M)//输出矩阵{for(int i=1, k=1;i<=M.mu;i++){for(int j=1;j<=M.nu;j++){if(M.data[k].i==i&&M.data[k].j==j){cout<<M.data[k].e<<"\t";k++;}elsecout<<"0\t";}cout<<endl;}cout<<"矩阵共有"<<M.mu<<"行"<<M.nu<<"列"<<M.tu<<"个非零元元素"<<endl;}void jiafa(Matrix M,Matrix N,Matrix& Q){if(M.mu!=N.mu||M.nu!=N.nu)cout<<"error"<<endl;Q.mu=M.mu;Q.nu=M.nu;Q.tu=0;int m,n,t;m=n=t=1;for(int row=1;row<=M.mu;row++){if(M.data[m].i==row&&N.data[n].i==row)//矩阵行数相等{if(M.data[m].j==N.data[n].j)//矩阵列数相等{int sum=M.data[m].e+N.data[n].e;if(sum!=0){Q.data[t].i=row;Q.data[t].j=M.data[m].j;Q.data[t].e=sum;Q.tu++;++m;++n;++t;}else{++m;++n;}}}while(M.data[m].i==row)//M矩阵剩下的元素{Q.data[t].i=row;Q.data[t].j=M.data[m].j;Q.data[t].e=M.data[m].e;Q.tu++;++m;++t;}while(N.data[n].i==row)//N矩阵剩下的元素{Q.data[t].i=row;Q.data[t].j=N.data[n].j;Q.data[t].e=N.data[n].e;Q.tu++;++n;++t;}}cout<<"矩阵相加结果为："<<endl;printmatrix(Q);cout<<endl;}void jianfa(Matrix M,Matrix N,Matrix& Q){if(M.mu!=N.mu||M.nu!=M.nu)cout<<"error"<<endl;Q.mu=M.mu;Q.nu=M.nu;Q.tu=0;int m,n,t;m=n=t=1;for(int row=1;row<=M.mu;row++){if(M.data[m].i==row&&N.data[n].i==row)//矩阵行数相等{if(M.data[m].j==N.data[n].j)//矩阵列数相等{int cha=M.data[m].e-N.data[n].e;if(cha!=0){Q.data[t].i=row;Q.data[t].j=M.data[m].j;Q.data[t].e=cha;Q.tu++;m++;n++;t++;}else{m++;n++;}}}while(M.data[m].i==row)//M矩阵剩下的元素{Q.data[t].i=row;Q.data[t].j=M.data[m].j;Q.data[t].e=M.data[m].e;Q.tu++;m++;t++;}while(N.data[n].i==row)//N矩阵剩下的元素{Q.data[t].i=row;Q.data[t].j=N.data[n].j;int e1=N.data[n].e;e1=0-e1;Q.data[t].e=e1;Q.tu++;n++;t++;}}cout<<"矩阵相减结果为"<<endl;printmatrix(Q);cout<<endl;}void chengfa(Matrix M,Matrix N,Matrix& Q){int ctemp[MAXSIZE+1];int tp,t,col,p,q;int arow=1,brow=1;if(M.nu!=N.mu)//稀疏矩阵M的列数和N的行数不相等，不能相乘cout<<"error"<<endl;Q.mu=M.mu;Q.nu=N.nu;Q.tu=0;if(M.tu*N.tu!=0){for(arow=1;arow<=M.mu;arow++){for(int i=1;i<=Q.nu;i++)ctemp[i]=0;//当前行各元素累加器清零Q.rpos[arow]=Q.tu+1;if(arow<M.mu)tp=M.rpos[arow+1];elsetp=M.tu+1;for( p=M.rpos[arow];p<tp;p++)//对当前行中的每一个非零元{brow=M.data[p].j; //找到对应元在N中的行号if(brow<N.mu)t=N.rpos[brow+1];elset=N.tu+1;for( q=N.rpos[brow];q<t;q++){col=N.data[q].j;//乘积元素在Q中列号ctemp[col]+=M.data[p].e * N.data[q].e;}}for(col=1;col<=Q.nu;col++)//压缩存储该行非零元if(ctemp[col]){if(++Q.tu>MAXSIZE)cout<<"error"<<endl;Q.data[Q.tu].i=arow;Q.data[Q.tu].j=col;Q.data[Q.tu].e=ctemp[col];}}}cout<<"矩阵相乘结果为："<<endl;printmatrix(Q);cout<<endl;}int main(){int chioce;Matrix M,N,Q;int i;cout<<"1、输入矩阵1："<<endl;cout<<"2、输入矩阵2："<<endl;cout<<"3、矩阵相加"<<endl;cout<<"4、矩阵相减"<<endl;cout<<"5、矩阵相乘"<<endl;cout<<"6、结束"<<endl;cout<<"输入选择功能："<<endl;do{cin>>chioce;switch(chioce){case 1:creatematrix(M);printmatrix(M);i=1;break;case 2:creatematrix(N);printmatrix(N);i=1;break;case 3:jiafa(M,N,Q);i=1;break;case 4:jianfa(M,N,Q);i=1;break;case 5:chengfa(M,N,Q);i=1;break;case 6:i=0;}cout<<"输入选择功能："<<endl;}while(i!=0);return 0;}四、调试分析1、开始对三元组了解不彻底，致使代码总是出现基本错误2、对于矩阵相乘的算法参考了书很久，并请教了同学3、矩阵乘法运算在调试中出现多次错误，反复试验才调试好五、用户手册1.本程序的运行环境为DOS操作系统，执行文件为TestMaze.exe2.进入演示程序后即显示文本方式的用户界面：。

数据结构----稀疏矩阵运算器课程设计目录稀疏矩阵运算器设计............................................................................................ I摘要................................................................................................................ ... II第一章需求分析 (1)第二章概要设计 (2)第三章设计步骤 (6)3.1 函数说明 (6)3.2 设计步骤 (7)第四章设计理论分析方法 (20)4.1 算法一：矩阵转置.....................................................................204.2 算法二：矩阵加法.....................................................................204.3 算法三：矩阵乘法 (21)第五章程序调试 (23)第六章心得体会 (25)参考文献 (26)第一章需求分析1．稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

2．以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现矩阵转置，求逆，实现两个矩阵相加、相减和相乘的运算。

稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。

3．演示程序以用户和计算机的对话方式执行，数组的建立方式为边输入边建立。

4．由题目要求可知：首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。

5．程序可以对三元组的输入顺序不加以限制；根据对矩阵的行列，三元组作直接插入排序，从而进行运算时,不会产生错误。

数据结构稀疏矩阵运算器引言：稀疏矩阵是指在一个二维矩阵中，绝大多数元素为0或者没有意义的元素。

与之相对，稠密矩阵则是指大部分元素都有意义且不为0的矩阵。

稀疏矩阵在很多实际问题中经常出现，例如图论、网络分析、自然语言处理等领域。

为了高效地处理稀疏矩阵的运算，我们可以使用稀疏矩阵运算器。

一、稀疏矩阵的表示方法对于一个m×n的稀疏矩阵，我们可以使用三元组(Triplet)的方式进行表示。

三元组表示法包括三个数组：行数组row、列数组col 和值数组value。

其中，row[i]和col[i]分别表示第i个非零元素的行和列，value[i]表示第i个非零元素的值。

通过这种方式，我们可以用较少的空间来表示一个稀疏矩阵，从而提高运算效率。

二、稀疏矩阵的加法运算稀疏矩阵的加法运算可以通过遍历两个稀疏矩阵的非零元素，并将相同位置的元素相加得到结果。

具体步骤如下：1. 初始化一个新的稀疏矩阵result，其行数和列数与原始稀疏矩阵相同。

2. 遍历两个稀疏矩阵的非零元素，将相同位置的元素相加，并将结果存储在result中。

3. 返回result作为加法运算的结果。

三、稀疏矩阵的乘法运算稀疏矩阵的乘法运算可以通过矩阵的数学定义来实现。

具体步骤如下：1. 初始化一个新的稀疏矩阵result，其行数等于第一个稀疏矩阵的行数，列数等于第二个稀疏矩阵的列数。

2. 遍历第一个稀疏矩阵的每个非零元素，将其与第二个稀疏矩阵相应位置的元素相乘，并将结果累加到result中。

3. 返回result作为乘法运算的结果。

四、稀疏矩阵的转置运算稀疏矩阵的转置运算可以通过交换行数组row和列数组col来实现。

具体步骤如下：1. 初始化一个新的稀疏矩阵result，其行数等于原始稀疏矩阵的列数，列数等于原始稀疏矩阵的行数。

2. 将原始稀疏矩阵的行数组row赋值给result的列数组col，将原始稀疏矩阵的列数组col赋值给result的行数组row。

#include<stdio.h>#include<stdlib.h>#define maxsize 200typedef struct{int i,j;//i为非零元素在行，j为非零元所在列int e;//非零元}Tripe;typedef struct{Tripe data[maxsize];int h,l,total;//稀疏矩阵的行数列数及非零元个数}TSMatrix;void Creat(TSMatrix &M){//创建一个稀疏矩阵int a,b,c,x;scanf("%d,%d,%d",&M.h,&M.l,&M.total);for(x=1;x<=M.total;x++){printf("请输入第%d个稀疏矩阵的非零元素所在的行数列数用逗号隔开输完按回车键:\n",x);scanf("%d,%d,%d",&a,&b,&c);M.data[x].i=a;M.data[x].j=b;M.data[x].e=c;}}void Print(TSMatrix &S){//输出稀疏矩阵int x;int c,b,a[maxsize][maxsize];for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++)a[c][b]=0;//全部初始化为零for(x=1;x<=S.total;x++){a[S.data[x].i][S.data[x].j]+=S.data[x].e;//在矩阵的相应位置附上非零元素}for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++){printf("%4d",a[c][b]);if(b==S.l)printf("\n");}}void Add(TSMatrix T,TSMatrix V,TSMatrix &M){//加法运算int p=1,q=1;int b=1;if(T.h!=V.h||T.l!=V.l){printf("两矩阵行数或列数不同无法进行相加:\n"); exit(0);}while(p<=T.total&&q<=V.total){if(T.data[p].i==V.data[q].i){if(T.data[p].j==V.data[q].j){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e+V.data[q].e;p++;b++;q++;}else if(T.data[p].j<V.data[q].j){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].j>V.data[q].j){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}}else if(T.data[p].i<V.data[q].i){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].i>V.data[q].i){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}}//下面两个循环是把上面循环中未处理的数据添加到M中while(p<=T.total){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}while(q<=V.total){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}M.h=T.h;M.l=T.l;M.total=b-1; //b最后要减一，因为上面处理最后一个数时b也增加1了}void TransposTSMtrix(TSMatrix A,TSMatrix &B) //完成矩阵的转置，一次快速定位法{int j,t,p,q;int num[maxsize],position[maxsize];//num矩阵某列非零元个数，positionB.h=A.l;B.l=A.h;B.total=A.total;if(B.total){for(j=1;j<=A.l;j++)num[j]=0;for(t=1;t<=A.total;t++)num[A.data[t].j]++;position[1]=1;for(j=2;j<=A.l;j++)position[j]=position[j-1]+num[j-1];for(p=1;p<=A.total;p++){j=A.data[p].j;q=position[j];B.data[q].i=A.data[p].j;B.data[q].j=A.data[p].i;B.data[q].e=A.data[p].e;position[j]++;}}}void Jiansmatrix(TSMatrix M,TSMatrix N,TSMatrix &T){int m=1,n=1,t=1;if(M.h!=N.h||M.l!=N.l){printf("两矩阵行数或列数不同无法进行相减");exit(0);}T.h=M.h;T.l=M.l;while(m<=M.total&&n<=N.total){{if(M.data[m].i==N.data[n].i){if(M.data[m].j==N.data[n].j){if(M.data[m].e==N.data[n].e){T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;m++;n++;}else{T.data[t].e=M.data[m].e-N.data[n].e;T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;n++;}}else if(M.data[m].j<N.data[n].j){T.data[t].e=M.data[m].e;T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;}else if(M.data[m].j>N.data[n].j){T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}}else{if(M.data[m].i<N.data[n].i){T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}else {T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}}}}while(M.total==(m-1)&&n<=N.total){T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;T.data[t].e=N.data[n].e;t++;n++;}while(N.total==(n-1)&&m<=M.total){T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}T.total=t-1;}void Multsmatrix(TSMatrix M,TSMatrix N,TSMatrix &T) {int p,q,Qn=0;int a[200][200];if(M.l!=N.h){printf("两矩阵无法相乘");exit(0);}T.h=M.h;T.l=N.l;for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)a[p][q]=0;for(p=1;p<=M.total;p++)for(q=1;q<=N.total;q++)if(M.data[p].j==N.data[q].i){a[M.data[p].i][N.data[q].j]+=M.data[p].e*N.data[q].e;}for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)if(a[p][q]!=0){Qn++;T.data[Qn].e=a[p][q];T.data[Qn].i=p;T.data[Qn].j=q;}T.total=Qn;}void main(){TSMatrix ts1,ts2,ts3;int choice;do{printf("1.矩阵的转置!\n");printf("2.两个矩阵相加!\n");printf("3.两个矩阵相减!\n");printf("4.两个矩阵相乘!\n");printf("5.退出程序!\n");printf("请输入您的选择:\n");scanf("%d",&choice);switch(choice){case 1:printf("请输入矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts1);Print(ts1);TransposTSMtrix(ts1,ts2);printf("转置后的矩阵为:\n");Print(ts2);break;case 2:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts1);printf("第一个矩阵为:\n");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts2);printf("第二个矩阵为:\n");Print(ts2);Add(ts1,ts2,ts3);printf("以上两个矩阵相加后为:\n");Print(ts3);break;case 3:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts1);printf("第一个矩阵为:\n");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts2);printf("第二个矩阵为:\n");Print(ts2);Jiansmatrix(ts1,ts2,ts3);printf("以上两个矩阵相减后为:\n");Print(ts3);break;case 4:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts1);printf("第一个矩阵为:\n");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\n");Creat(ts2);printf("第二个矩阵为:\n");Print(ts2);Multsmatrix(ts1,ts2,ts3);printf("以上两个矩阵相乘后为:\n");Print(ts3);break;case 5:exit(0);break;}}while(choice!=0);scanf("%d",&choice);}。

数据结构——稀疏矩阵运算器数据结构——稀疏矩阵运算器1、简介1.1 背景稀疏矩阵是一种特殊的矩阵，其中包含大量的零元素。

与密集矩阵相比，稀疏矩阵在存储和计算上具有更高的效率。

稀疏矩阵运算器是一种特定的工具，用于执行稀疏矩阵的各种运算，如加法、减法、乘法等。

1.2 目的2、稀疏矩阵的定义与表示2.1 稀疏矩阵的定义稀疏矩阵是指在矩阵中只有部分元素非零的矩阵。

通常，如果矩阵中超过一定比例的元素为零，则可以将其称为稀疏矩阵。

2.2 稀疏矩阵的表示稀疏矩阵可以使用多种表示方式，如数组、链表、三元组等。

每种表示方式都有各自的特点和适用范围。

3、稀疏矩阵运算的基本概念3.1 稀疏矩阵加法稀疏矩阵加法是指对两个稀疏矩阵进行元素级别的相加操作。

该操作要求两个矩阵具有相同的维度。

3.2 稀疏矩阵减法稀疏矩阵减法是指对两个稀疏矩阵进行元素级别的相减操作。

该操作要求两个矩阵具有相同的维度。

3.3 稀疏矩阵乘法稀疏矩阵乘法是指对两个稀疏矩阵进行矩阵乘法运算。

该操作要求第一个矩阵的列数等于第二个矩阵的行数。

4、稀疏矩阵运算器的实现4.1 基本功能稀疏矩阵运算器应具备稀疏矩阵加法、减法和乘法的基本功能。

用户可以输入矩阵的维度和元素值，然后执行相应的运算。

4.2 稀疏矩阵的表示与存储稀疏矩阵的表示与存储是稀疏矩阵运算器的关键部分。

可以使用多种数据结构来表示和存储稀疏矩阵，如三元组、链表等。

4.3 稀疏矩阵运算的算法实现稀疏矩阵运算的算法实现是稀疏矩阵运算器的核心部分。

可以使用各种算法来实现稀疏矩阵的加法、减法和乘法运算。

5、附加功能与性能优化5.1 稀疏矩阵转置稀疏矩阵转置是指将稀疏矩阵的行与列进行交换。

该操作可以提高计算效率，并减少存储空间的使用。

5.2 稀疏矩阵的压缩与解压缩稀疏矩阵的压缩与解压缩是指将稀疏矩阵的存储空间进行优化，从而减少存储空间的使用。

5.3 算法的优化与性能测试稀疏矩阵运算器的性能优化是一个重要的方向。

一、引言稀疏矩阵是一个具有大量零元素的矩阵，对于大规模的矩阵来说，如果没有充分利用矩阵的稀疏性质，将会带来很大的存储空间和计算时间上的浪费。

为了解决这个问题，我们需要通过设计一个稀疏矩阵运算器来对稀疏矩阵进行各种运算，以提高计算效率。

二、实验目标本实验的主要目标是设计一个稀疏矩阵运算器，通过实现对稀疏矩阵的加法、乘法和转置等操作，实现对稀疏矩阵的高效运算。

三、设计思路和方法1. 矩阵的表示方式在设计稀疏矩阵运算器时，我们需要选择合适的数据结构来表示稀疏矩阵。

由于稀疏矩阵中大部分元素为零，我们可以采用压缩存储的方法来表示稀疏矩阵。

一种常用的压缩存储方法是使用三元组表示法，即将矩阵的非零元素的值、所在的行号和列号分别存储在一个三元组中。

2. 加法运算稀疏矩阵的加法运算是指将两个稀疏矩阵进行对应位置的相加操作。

在进行稀疏矩阵的加法运算时，首先需要判断两个矩阵的维度是否相同，然后通过遍历两个矩阵的非零元素，将相同位置的元素进行相加得到结果。

3. 乘法运算稀疏矩阵的乘法运算是指将两个稀疏矩阵进行矩阵乘法操作。

在进行稀疏矩阵的乘法运算时，首先需要判断第一个矩阵的列数是否等于第二个矩阵的行数，然后通过遍历两个矩阵的非零元素，按照行和列的顺序对应相乘，再将相乘的结果加到结果矩阵中。

4. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。

在进行稀疏矩阵的转置运算时，只需要将矩阵的非零元素的行号和列号对换即可。

五、实验结果与分析我们在实现稀疏矩阵运算器后，对其进行了测试。

通过测试，我们发现稀疏矩阵运算器能够正确地进行稀疏矩阵的加法、乘法和。

‘实验报告题目：稀疏矩阵运算器班级：14电子商务平台建设班完成日期：2015.11.2 学号：姓名：孙少辉学号：姓名：杨德龙学号：姓名：柴益新一：需求分析稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏“特点进行存储和计算可以大大节省存储空间，提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

【基本要求】以“带行逻辑链接信息“的三元组顺序表示稀疏矩阵，实现两个矩阵相加、相减和相乘运算。

稀疏矩阵的输入采用三元组表示，而运算结果的矩阵则以通常阵列形式列出。

【项目约束】1．首先应输入矩阵的行数和列数，并判断给出的两个矩阵行、列数对于所要求作的运算是否相匹配。

可设矩阵的行数和列数均不超过20。

2．程序可以对三元组的输入顺序加以限制，例如，按行优先。

注意研究教科书5.3.2节中的算法，以便提高计算效率。

3.在用三元组稀疏矩阵时，相加或相减所得结果矩阵应该另生成，乘积矩阵也可用二维数组存放。

三：详细设计1：数据结构的定义元素类型、变量、指针类型（1）项目数据表：3.2子函数3：函数调用关系无函数调用关系，只有一个主函数四：调试分析三元组顺序的输入规则。

以0 0 0 作为输入的结束信号。

完成实现稀疏矩阵的相加、相减、相乘的运算。

五：用户使用说明(1)首先运行文件系统1.首先定义要运算的第一个稀疏矩阵的行列数定义完成之后输入另一个要运算的稀疏矩阵的行列。

(2)输入信息：如下图所示输入两个矩阵的元素所有输入信息以及运算方法输入完成之后。

回车直接算出结果(3)输出信息：六、源代码/*****项目名称：稀疏矩阵的运算***设计者：杨德龙，柴益新，孙少辉***时间：2015.11.02***实现目标：实现矩阵的加法，减法，乘法；***/#include<stdio.h>#include<windows.h>int main(){//定义二维数组及用到的各种变量int a[20][20];int b[20][20];int c[20][20];int m,n,k,l,i,j,p;int sum;int o;char t;//输入操作printf("请输入第一个矩阵的行列\n");scanf("%d%d",&n,&m); //初始化a数组for(i=0;i<n;i++)for(j=0;j<m;j++)a[i][j]=0;printf("请输入第二个矩阵的行列\n");scanf("%d%d",&k,&l); //初始化b数组for(i=0;i<n;i++)for(j=0;j<m;j++)b[i][j]=0;printf("请用三元组的方式输入第一个矩阵(例1 1 1)（输入0 0 0时结束）\n");while(true){scanf("%d%d%d",&i,&j,&p);if(i==0 && j==0 && p==0)break;elsea[i-1][j-1]=p;}printf("请用三元组的方式输入第二个矩阵(例1 1 1)（输入0 0 0时结束）\n");while(true){scanf("%d%d%d",&i,&j,&p);if(i==0 && j==0 && p==0)break;elseb[i-1][j-1]=p;}printf("请输入执行操作（+或-或*）\n");while(true){getchar();scanf("%c",&t);if(t=='+') //加法运算{{printf("不能进行该运算！！");exit(0); //结束}else{printf("答案为：\n");for(i=0;i<n;i++){for(j=0;j<m;j++){printf("%d ",a[i][j]+b[i][j]);}printf("\n");}exit(0); //结束}}else if(t=='-') //减法运算{{printf("不能进行该运算！！");exit(0); //结束}else{printf("答案为：\n");for(i=0;i<n;i++){for(j=0;j<m;j++){printf("%d ",a[i][j]-b[i][j]);}printf("\n");}exit(0); //结束}}else if(t=='*') //乘法运算{if(m!=k){printf("不能进行该运算！！");exit(0); //结束}else{printf("答案为：\n");for(o=0;o<n;o++){for(i=0;i<l;i++){sum=0;for(j=0;j<m;j++){sum=sum+a[o][j]*b[j][i];}printf("%d ",sum);}printf("\n");}exit(0); //结束}v .. . ..}elseprintf("输入符号错误，重新输入：\n");}return 0; //结束}. . . 资料. .。