数据结构实验稀疏矩阵计算器
稀疏矩阵运算器-数据结构课程设计
实习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、抽象数据类型定义如下： ADT SparseMatrix{ 数据对象D：D=｛aij|i=1,2,3…,m;j=1,2,3…,n; ai ∈ElemSet,m和n分别称为矩阵的行数和列数｝ 数据关系R： R={Row,Col} Row={<ai,j,ai,j+1>|1≤i≤m, 1≤j≤n-1} Col={<ai,ai+1,j>|1≤i≤m-1, 1≤j≤n} 基本操作 本程序中，用三元组顺序表作为存储结构。 (1)、CreatSMatrix (TSMatrix &M) 操作结果：创建矩阵M。 (2)、AddSMatrix(TSMatrix A,TSMatrix B,TSMatrix &C,int n) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (3)、SubMatrix (TSMatrix *a,TSMatrix *b) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (4)、MultiplicationMatrixPow (TSMatrix *a,TSMatrix *b,TSMatrix *c) 初始条件：矩阵A和B的行数和列数匹配 操作结果：求矩阵A、B的和C=A*B。 (5) OutputSMatrix(TSMatrix M) 初始条件：矩阵M已存在 操作结果：输出矩阵M 2、 本程序包含5个模块
for(i=1;i<=M->mu;i++)//输出矩阵 { for(j=1;j<=M->nu;j++) printf("%5d",a[i][j]); printf("\n"); } } //*************矩阵的求和运算*****************// int AddSMatrix(TSMatrix *M,TSMatrix *N,TSMatrix *Q)//求 采用三元组顺序表存储表示的稀疏矩阵M和N的和,结果赋给矩阵Q { int i,j,p,q,x=0,y=0; if((M->mu<=0)||(M->nu<=0)||(M->tu<=0)||(N->mu<=0)||(N>nu<=0)||(N->tu<=0))//判断行数列数非零元素个数是否符合匹配 return ERROR; if(M->mu!=N->mu||M->nu!=N->nu)//判断A与B的行列数 是否相等的 return ERROR; Q->mu=M->mu;//矩阵Q的初始化 Q->nu=M->nu; Q->tu=0; for(i=1;i<=Q->mu;i++) { for(j=1;j<=Q->nu;j++)//寻找矩阵M,N中非零元素相等 的行列 { for(p=1;p<=M->tu;p++)//求矩阵M行列中所对应的 非零元素的值 赋值给X { if((i==M->data[p].row)&&(j==M->data[p].col))// 如果i是矩阵M中非零元素行，j是其列 { x=M->data[p].e;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
‘
实验报告
题目：稀疏矩阵运算器
班级：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;
else
a[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;
else
b[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 .. . ..
}
else
printf("输入符号错误，重新输入：\n");
}
return 0; //结束
}
. . . 资料. .。