实现稀疏矩阵的基本运算实验报告

合集下载

【数据结构算法】实验3 稀疏矩阵基本操作-顺序结构(附源代码)

【数据结构算法】实验3 稀疏矩阵基本操作-顺序结构(附源代码)

浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验三稀疏矩阵的基本操作--用顺序存储结构实验成绩指导老师(签名)日期一.实验目的和要求1.了解稀疏矩阵的三元组线性表存储方法。

2.掌握稀疏矩阵采用顺序存储结构时基本操作的实现。

二. 实验内容1.编写稀疏矩阵采用顺序存储结构时基本操作的实现函数。

基本操作包括:①初始化稀疏矩阵;②输入稀疏矩阵;③输出稀疏矩阵;④稀疏矩阵的相加运算。

要求把稀疏矩阵的存储结构定义及基本操作实现函数存放在头文件SeqMatrix.h中,主函数main() 存放在主文件test7_1.cpp中,在主函数中通过调用SeqMatrix.h中的函数进行测试。

2.选做:编写稀疏矩阵的相乘运算实现函数,要求把该函数添加到头文件SeqMatrix.h中,并在主文件t est7_1.cpp中添加相应语句进行测试。

3.填写实验报告,实验报告文件取名为report3.doc。

4.上传实验报告文件report3.doc与源程序文件SeqMatrix.h及test7_1.cpp到Ftp服务器上你自己的文件夹下。

三. 函数的功能说明及算法思路包括每个函数的功能说明,及一些重要函数的算法实现思路函数:void InitMatrix(SMatrix &M)功能:初始化稀疏矩阵思路:将稀疏矩阵的行、列、元素个数均置为0函数:void InputMatrix(SMatrix &M, int m, int n)功能:输入稀疏矩阵思路:以行、列、值的方式输入稀疏矩阵的每个元素函数:void OutputMatrix(SMatrix M)功能:输出稀疏矩阵思路:以行、列、值的方式输出稀疏矩阵的每个元素函数:SMatrix Add(SMatrix M1, SMatrix M2)功能:稀疏矩阵的相加运算思路:遍历M1与M2,若两者的当前元素行列号相等则将值相加,形成新的元素加入结果矩阵M (若为0则忽略),若不相等则按行列号顺序将小的那个加入结果矩阵M函数:SMatrix Multiply(SMatrix M1, SMatrix M2) 功能:选作:稀疏矩阵的相乘运算思路:嵌套遍历M1与M2,当M1的当前元素列号与M2的当前元素行号相等时相乘两个数,并将结果暂存入单链表。

稀疏矩阵运算器实验报告

稀疏矩阵运算器实验报告
Ne=&N.data[N.tu]; // Ne指向矩阵N的非零元素尾地址
Qh=Qe=Q.data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址
while(Mp<=Me&&Np<=Ne)
{
Qe++;
switch(comp(Mp->i,Np->i))
{
case 1: *Qe=*Mp;
Mp++;
while(Mp<=Me)
{
Qe++;
*Qe=*Mp;
Mp++;
}
Q.tu=Qe-Qh; //矩阵Q的非零元素个数
return 1;
}
int MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q) {
//求矩阵乘积Q=M?N,采用行逻辑链接存储表示。
int arow,brow,p,q,t,ctemp[30],l,ccol,tp;
稀疏矩阵运算器
一:问题描述:
稀疏矩阵是指那些多数元素为零的矩阵。利用稀疏特点进行储存和计算可以大大节省储存空间,提高计算效率。实现一个能进行称稀疏矩阵基本运算的运算器。
基本要求:
以带逻辑链接信息的三元组顺序表表示稀疏矩阵,实现矩阵相加,相减,相乘的运算。稀疏矩阵的输入形式采用三元组表示。而运算结果的矩阵则用通常的阵列形式列出。
else t = N.tu+1;
for (q=N.rpos[brow]; q< t; ++q) {
ccol = N.data[q].j; //乘积元素在Q中列号
ctemp[ccol] += M.data[p].e * N.data[q].e;

数据结构实验四稀疏矩阵运算

数据结构实验四稀疏矩阵运算

数据结构实验四稀疏矩阵运算1、实验目的掌握三元组法存储稀疏矩阵的方法及相关的基本操作。

2、实验内容∙用三元组法存放稀疏矩阵∙求出矩阵转置结果∙求出矩阵相乘结果∙输出结果矩阵3、实验要求∙用数组存放矩阵的三元组,矩阵的行数和列数及非0数据从键盘输入∙要求采用稀疏矩阵快速转置算法∙若两个矩阵不能相乘则输出“Error”4、试验参考程序typedef s tr uct { // 定义三元组的元素int i, j;int e;} Tr iple;typedef s tr uct { // 定义矩阵Tr iple data[MA XSI ZE + 1];int mu, nu, tu;} TSMa tr ix;typedef s tr uct { // 定义行逻辑连接矩阵Tr iple data[MA XSI ZE + 2];int rpos[MA XROW + 1];int mu, nu, tu;} RLSMatr ix;矩阵输入函数bool InPutT SMat r ix(T SMatr ix & T) {cout << "输入矩阵的行,列和非零元素个数:" << e ndl;cin >> T.mu >> T.nu >> T.tu;cout << "请输出非零元素的位置和值:" << e ndl;for (int k = 1;; k <= T.t u; k++)cin >> T.data[k].i >> T.da ta[k].j >> T.data[k].e;retur n t rue;}请补充完成下列矩阵转置函数、矩阵乘法函数与矩阵输出函数Bool Trans poseSMa tr ix(T SMa t r ix M, T SMat r ix & T){TSMatrix M,T; //定义预转置的矩阵InPutTSMatrix(M, 0); //输入矩阵int num[MAXROW+1];int cpot[MAXROW+1]; // 构建辅助数组int q,p,t;T.tu=M.tu; T.mu=M.nu; T.nu=M.mu;if(T.tu){for(int col=1;col<=M.nu;col++) num[col]=0;for(t=1;t<=M.tu;t++) ++num[M.data[t].j];cpot[1]=1;for(int i=2;i<=M.nu;i++) cpot[i]=cpot[i-1]+num[i-1]; // 求出每一列中非零元素在三元组中出现的位置for(p=1;p<=M.tu;p++){col=M.data[p].j; q=cpot[col];T.data[q].i=col; T.data[q].j=M.data[p].i;T.data[q].e=M.data[p].e; ++cpot[col];}}cout<<"输入矩阵的转置矩阵为"<<endl;OutPutSMatrix(T);return true;}Bool MultSMatr ix(RLSMatr ix M, RL SMatr ix N,RL SMat r ix & T){RLSMatrix M,N,Q; // 构建三个带“链接信息”的三元组表示的数组InPutTSMatrix(M,1); // 用普通三元组形式输入数组InPutTSMatrix(N,1);Count(M); Count(N);if(M.nu!=N.mu) return false;Q.mu=M.mu; Q.nu=N.nu; Q.tu=0; // Q初始化int ctemp[MAXROW+1]; // 辅助数组int arow,tp,p,brow,t,q,ccol;if(M.tu*N.tu){ // Q是非零矩阵for( arow=1;arow<=M.mu;arow++){///memset(ctemp,0,N.nu);for(int x=1;x<=N.nu;x++) // 当前行各元素累加器清零ctemp[x]=0;Q.rpos[arow]=Q.tu+1; // 当前行的首个非零元素在三元组中的位置为此行前所有非零元素+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; // 在N中找到i值也操作元素的j值相等的行if(brow<N.mu) t=N.rpos[brow+1];else t=N.tu+1;for(q=N.rpos[brow];q<t;q++){ // 对找出的行当每个非零元素进行操作ccol=N.data[q].j;ctemp[ccol] += M.data[p].e*N.data[q].e; // 将乘得到对应值放在相应的元素累加器里面}}for(ccol=1;ccol<=Q.nu;ccol++) // 对已经求出的累加器中的值压缩到Q中if(ctemp[ccol]){if(++Q.tu>MAXSIZE) return false;Q.data[Q.tu].e=ctemp[ccol];Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;}}OutPutSMatrix(Q);return true;}}boo l O utP utSMatrix(T SMat r ix T){// 输出矩阵,按标准格式输出int m,n,k=1;fo r(m=0;m<T.mu;m++){fo r(n=0;n<T.nu;n++){if((T.d a ta[k].i-1)==m&&(T.d a ta[k].j-1)==n){co ut.w id th(4);co ut<<T.d a ta[k++].e;}e ls e{co ut.w id th(4); co ut<<"0"; }}co ut<<e nd l;}re turn true;}}并建立ma in()函数对上述函数进行测试。

数据结构实验报告三稀疏矩阵的运算

数据结构实验报告三稀疏矩阵的运算

数据结构实验报告三稀疏矩阵的运算实验课程名称数据结构课程设计专业班级学⽣姓名学号指导教师2012 ⾄ 2013 学年第⼀学期第 1 ⾄ 18 周⽬录实验题⽬:稀疏矩阵的运算 (3)⼀:概述 (3)⼆:系统分析 (3)三:概要设计 (3)四:详细设计 (4)五:运⾏与测试 (9)六:总结与⼼得 (9)实验题⽬:稀疏矩阵的运算⼀:概述本实验设计主要实现在⼗字链表存储结构输⼊稀疏矩阵,并对稀疏矩阵进⾏相加操作,最后输出运算结果。

⼆:系统分析本实验要求设计函数在⼗字链表结构下建⽴稀疏矩阵并初始化,在创建稀疏矩阵时,需要设计在⼗字链表下创建稀疏矩阵,在输⼊出现错误时,能够对错误进⾏判别处理,初始化稀疏矩阵都为空值。

在设计输出稀疏矩阵的值的函数时,根据情况编制函数,才能准确的输出稀疏矩阵。

在对稀疏矩阵进⾏初始化时,只输⼊⾮零元素的值和它所在的所在⾏及所在列。

在对稀疏矩阵输出时,以矩阵的完整形式输出。

除此之外还要求设计相加对两个矩阵进⾏运算,并输出最终的稀疏矩阵,定义相应的矩阵类型⽤于存放两个矩阵操作后的结果矩阵,这个结果矩阵的⾏、列数需要综合多⽅⾯情况来确定。

这些函数也是整个程序的难点,需要灵活运⽤数组及指针的特点。

三:概要设计⼗字链表结构体定义:typedef struct sex{int row,col,val; //⾮零元素的⾏、列下标及值struct sex *right,*dowm; //该⾮零元素所在⾏表和列表的后继元素}Node;矩阵的加法:此功能在⼗字链表存储结构下,由函数void addition(Node *cp1, Node *cp2, Node *cp3)实现。

当⽤户选择该功能,系统即提⽰⽤户初始化要进⾏加法的两个矩阵的信息。

然后进⾏加法,最后输出结果。

四:详细设计#include#includetypedef struct sex{int row,col,val; //⾮零元素的⾏、列下标及值struct sex *right,*dowm; //该⾮零元素所在⾏表和列表的后继元素}Node;Node * Init(int m, int n){int t,i;Node *cp;t=(m>=n)?m:n;cp=(Node *)malloc( (t+1)*sizeof(Node) ); //开辟⼀串连续的内存空间(*cp).row=m;(*cp).col=n;(*cp).val=t; //此表头结点的值域⽤来记录⾏列的最⼤值,以便于后⾯的开辟空间for(i=1;i<=t;i++){cp[i].right=cp+i;cp[i].dowm=cp+i; //构成带表头结点的空循环单链表}return cp;}void CreatCrossList(Node *cp){int t,i;Node *s,*temp;printf("请输⼊⾮零元素的个数N:");scanf("%d",&t);printf("\n请输⼊其对应坐标及元素值:\n");for(i=0;i{s=(Node *)malloc( sizeof(Node));scanf("%d%d%d",&s->row,&(*s).col,&s->val);temp=cp+s->row;if( temp->right!=cp+s->row )while( temp->right!=cp+s->row && temp->right->col<=s->col )temp=temp->right;s->right=temp->right;temp->right=s; //修改⾏链表插⼊位置temp=cp+s->col;if( temp->dowm!=cp+s->col )while( temp->dowm!=cp+s->col && temp->dowm->row<=s->row )temp=temp->dowm;s->dowm=temp->dowm;temp->dowm=s; //修改列链表插⼊位置}}void output(Node *cp){int i;Node *temp;printf("\n稀疏矩阵如下:\n");for(i=1;i<=cp->row;i++){temp=cp+i;while( temp->right!=cp+i ){printf("(%d,%d %d)",temp->right->row,temp->right->col,temp->right->val); temp=temp->right;}printf("\n");}}void Insert(Node *cp, Node *s){//此插⼊函数的作⽤是:⽣成⽬标矩阵Node *temp;temp=cp+s->row; //修改⾏链表指针if( temp->right!=cp+s->row )while( temp->right!=cp+s->row && temp->right->col<=s->col ) temp=temp->right;s->right=temp->right;temp->right=s;temp=cp+s->col; //修改列链表指针if( temp->dowm!=cp+s->col )while( temp->dowm!=cp+s->col && temp->dowm->row<=s->row ) temp=temp->dowm;s->dowm=temp->dowm;temp->dowm=s;}void addition(Node *cp1, Node *cp2, Node *cp3){int i;Node *w,*p,*q;for( i=1; i<=cp2->row && i<=cp3->row; i++){p=cp2+i;q=cp3+i;while( p->right!=cp2+i && q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;if( p->right->col==q->right->col ){w->col=p->right->col;w->val=p->right->val+q->right->val; //相同位置上的元素值相加p=p->right;q=q->right;if( w->val )Insert(cp1,w); //把⾮零元插⼊到⽬标矩阵中}else if( p->right->colright->col ){w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w); //把cp2中的⾮零元插⼊到⽬标矩阵中}else{w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w); //把cp2中的⾮零元插⼊到⽬标矩阵中}}if( p->right==cp2+i )while( q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=q->right->row;w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w); //把cp3中剩余的⾮零元插⼊⽬标矩阵中} else if( q->right==cp3+i )while( p->right!=cp2+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w); //把cp2中剩余的⾮零元插⼊到⽬标矩阵中} else; //两个矩阵同⼀⾏中同时结束}if( i>cp2->row)while(i<=cp3->row){//把cp3中剩余⾏中的⾮零元插⼊到⽬标矩阵中q=cp3+i;while( q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=q->right->row;w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w);}i++; //继续下⼀⾏}else if(i>cp3->row)while( i<=cp2->row ){p=cp2+i;while( p->right!=cp2+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w);}i++; //继续下⼀⾏}}int main(){Node *cp1, *cp2, *cp3;int a, b;printf("\t\t\t*****稀疏矩阵的加法*****\n\n");printf("请输⼊cp2的⾏、列数:");scanf("%d%d",&a,&b);cp2=Init(a,b);printf("请输⼊cp3的⾏、列数:");scanf("%d%d",&a,&b);cp3=Init(a,b);a=cp2->row>=cp3->row?cp2->row:cp3->row;b=cp2->col>=cp3->col?cp2->col:cp3->col;cp1=Init(a,b); //开始初始化结果矩阵printf("\n\t>>>>>>>创建稀疏矩阵cp2\n");CreatCrossList(cp2);printf("\n\t>>>>>>>创建稀疏矩阵cp3\n");CreatCrossList(cp3);output(cp2);output(cp3);addition(cp1,cp2,cp3);printf("\n\n相加后的"); output(cp1);return 0;}五:运⾏与测试进⾏数据测试六:总结与⼼得⼗字链表作为存储结构表⽰随机稀疏矩阵,进⾏两矩阵的相加运算,所以⾸先要定义⼀个⼗字链表作为存储结构。

稀疏矩阵基本操作 实验报告

稀疏矩阵基本操作 实验报告

稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵得压缩储存结构,以及稀疏矩阵得三元组表表示方法下得转置、相加、相乘等算法二、实验目得1.熟悉数组、矩阵得定义与基本操作2.熟悉稀疏矩阵得储存方式与基本运算3.理解稀疏矩阵得三元组表类型定义,掌握稀疏矩阵得输入、输出与转置算法三、实验原理1.使用三元组储存矩阵中得非零元素(三元组分别储存非零元素得行下标,列下标与元素值)。

除了三元组表本身,储存一个稀疏矩阵还需要额外得三个变量,分别储存矩阵得非零元个数,矩阵得行数与矩阵得列数。

2.稀疏矩阵得创建算法:第一步:根据矩阵创建一个二维数组,表示原始矩阵第二步:取出二维数组中得元素(从第一个元素开始取),判断取出元素就是否为非零元素,如果为非零元素,把该非零元素得数值以及行下标与列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。

第三步:重复第二步,知道二维数组中所有得元素已经取出。

3.稀疏矩阵倒置算法:第一步:判断进行倒置得矩阵就是否为空矩阵,如果就是,则直接返回错误信息、第二步:计算要倒置得矩阵每列非零元素得数量,存入到num数组(其中num[i]代表矩阵中第i列非零元素得个数)、以及倒置后矩阵每行首非零元得位置,存入cp ot数组中(其中cpot表示倒置后矩阵每行非零元得位置,对应表示原矩阵每列中第一个非零元得位置)。

第三步:确定倒置后矩阵得行数与列数。

第四步:取出表示要导致矩阵中三元组表元素{e, I, j}(第一次取出第一个,依次取出下一个元素),从第二步cpot数组中确定该元素倒置后存放得位置(cpot[j]),把该元素得行下标与列下标倒置以后放入新表得指定位置中。

cpot[j]变量加一。

第五步:重复第四步,直到三元组表中所有得元素都完成倒置。

第六步:把完成倒置运算得三元组表输出、4.稀疏矩阵加法算法:第一步:检查相加两个矩阵得行数与列数就是否相同,如果相同,则进入第二步,否则输出错误信息。

第二步:定义变量i与j,用于控制三元组表得遍历。

稀疏矩阵(实验报告)

稀疏矩阵(实验报告)

《数据结构课程设计》实验报告一、实验目的:理解稀疏矩阵的加法运算,掌握稀疏矩阵的存储方法,即顺序存储的方式,利用顺序存储的特点——每一个元素都有一个直接前驱和一个直接后继,完成相关的操作。

二、内容与设计思想:1、设计思想1)主界面的设计定义两个矩阵a= 0 0 3 0 0 0 0 0 b= 0 2 0 0 0 0 0 00 0 0 0 0 0 5 0 0 0 0 4 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 6 0 00 0 0 0 7 0 0 0 0 0 0 0 8 0 0 00 0 0 0 0 0 0 0 0 0 1 0 0 0 0 00 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0定义两个数组A和B,用于存储矩阵a和矩阵b的值;定义一个数组C,用于存放数组A 和数组B相加后的结果。

2)实现方式稀疏矩阵的存储比较浪费空间,所以我们可以定义两个数组A、B,采用压缩存储的方式来对上面的两个矩阵进行存储。

具体的方法是,将非零元素的值和它所在的行号、列号作为一个结点存放在一起,这就唯一确定一个非零元素的三元组(i、j、v)。

将表示稀疏矩阵的非零元素的三元组按行优先的顺序排列,则得到一个其结点均为三元组的线性表。

即:以一维数组顺序存放非零元素的行号、列号和数值,行号-1作为结束标志。

例如,上面的矩阵a,利用数组A存储后内容为:A[0]=0,A[1]=2, A[2]=3, A[3]=1, A[4]=6, A[5]=5, A[6]=3, A[7]=4, A[8]=7, A[9]=5, A[10]=1, A[11]=9, A[12]=-1同理,用数组B存储矩阵b的值。

2、主要数据结构稀疏矩阵的转存算法:void CreateMatrix(int A[m][n],int B[50]){int i,j,k=0;for(i=0;i<m;i++)for(j=0;j<n;j++)if(A[i][j]!=0){B[k]=i;k++;B[k]=j;k++;B[k]=A[i][j];k++;}B[k]=-1;}稀疏矩阵的加法实现:3、主要算法结构分析:1)void CreateMatrix(int A[m][n],int B[50]),这是一个将稀疏矩阵转存的函数,类似于顺序存储三元组表。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算实验目的:1.学习并理解稀疏矩阵的概念、特点以及存储方式。

2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。

3.实现稀疏矩阵加法、乘法的算法,并进行性能测试和分析。

实验原理:稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。

在实际问题中,有许多矩阵具有稀疏性,例如文本矩阵、图像矩阵等。

由于存储稀疏矩阵时,对于大量的零元素进行存储是一种浪费空间的行为,因此需要采用一种特殊的存储方式。

常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。

其中,三元组顺序表是最简单直观的一种方式,它是将非零元素按行优先的顺序存储起来,每个元素由三个参数组成:行号、列号和元素值。

此外,还需要记录稀疏矩阵的行数、列数和非零元素个数。

稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历,对于相同位置的元素进行相加,得到结果矩阵。

稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算,即行乘以列的和。

实验步骤:1.实现稀疏矩阵的三元组顺序表存储方式,并完成稀疏矩阵的初始化、转置、打印等基本操作。

2.实现稀疏矩阵的加法运算,并进行性能测试和分析。

3.实现稀疏矩阵的乘法运算,并进行性能测试和分析。

4.编写实验报告。

实验结果:经过实验测试,稀疏矩阵的加法和乘法算法都能正确运行,并且在处理稀疏矩阵时能够有效节省存储空间。

性能测试结果表明,稀疏矩阵加法、乘法的运行时间与非零元素个数有关,当非零元素个数较少时,运算速度较快;当非零元素个数较多时,运算速度较慢。

实验分析:稀疏矩阵的运算相对于普通矩阵的运算有明显的优势,可以节省存储空间和运算时间。

在实际应用中,稀疏矩阵的存储方式和运算算法都可以进行优化。

例如,可以采用行逻辑链接表的方式存储稀疏矩阵,进一步减少存储空间的占用;可以采用并行计算的策略加快稀疏矩阵的运算速度。

总结:通过本次实验,我深入学习了稀疏矩阵的概念、特点和存储方式,掌握了稀疏矩阵加法、乘法的基本思想和算法,并通过实验实现了稀疏矩阵的加法、乘法运算。

实验五 稀疏矩阵的实验

实验五  稀疏矩阵的实验

实验五稀疏矩阵的实验【实验目的】1、掌握稀疏矩阵的三元组表示法2、学会应用稀疏矩阵的三元组表示法实现稀疏矩阵的运算【实验说明】参考下列步骤完成实验1、三元组存储结构定义# include <stdio.h># include <stdlib.h># define MAXSIZE 1000typedef int ElementType;typedef struct{int row,col;ElementType e;}Triple;typedef struct{Triple data[MAXSIZE+1];int m,n,len;}TSMatrix;2、创建三元组void CreateTmatrix (TSMatrix *A){int i,j; ElementType x;int p;printf("请输入矩阵总的行数,列数及非零元的个数(逗号相隔):");scanf("%d,%d,%d",&A->m,&A->n,&A->len);printf("\n请输入矩阵的三元组(逗号相隔)\n");for(p=1;p<=A->len;p++){scanf("%d,%d,%d",&i,&j,&x);A->data[p].row=i;A->data[p].col=j;A->data[p].e=x;}}//CreateTmatrix3、应用三元组存储稀疏矩阵并实现由矩阵A得其转置矩阵Bvoid TransposeTSMatrix(TSMatrix A,TSMatrix *B){//把矩阵A转置到B所反指向的矩阵中去。

矩阵用三元组表示int i,j,k;B->m=A.n;B->n=A.m;B->len=A.len;if(B->len>0){j=1;for(k=1;k<=A.n;k++)for(i=1;i<=A.len;i++)if(A.data[i].col==k){B->data[j].row=A.data[i].col;B->data[j].col=A.data[i].row;B->data[j].e=A.data[i].e;j++;}}}//TransposeTSMatrix4、以矩阵形式输出稀疏矩阵void output1(TSMatrix A){ ElementType M[50][50];int i,j,rmax,cmax;rmax=A.m; //得到最大的行数cmax=A.n;for(i=0;i<rmax;i++)for(j=0;j<cmax;j++)M[i][j]=0;for(i=1;i<=A.len;i++)M[A.data[i].row-1][A.data[i].col-1]=A.data[i].e;for(i=0;i<rmax;i++){ for(j=0;j<cmax;j++) printf("%5d ",M[i][j]);printf("\n");}}5、以三元组形式输出稀疏矩阵void output3(TSMatrix A) {int i;printf("\n");for(i=1;i<=A.len;i++){ printf(" %3d %3d %3d",A.data[i].row,A.data[i].col,A.data[i].e);printf("\n");}}//output3//主调函数void main(){TSMatrix A,B;CreateTmatrix(&A);printf("原矩阵:\n");output1(A);TransposeTSMatrix(A,&B);printf("\n转置矩阵:\n");output1(B);printf("\n转置矩阵的三元组形式:\n");output3(B);}【实验内容】⑴以一次定位快速转置法实现稀疏矩阵的转置运算;⑵若矩阵A m×n中的某个元素a ij是第i行中的最小值,同时又是第j 列中的最大值,则称此元素为该矩阵中的一个马鞍点。

稀疏矩阵编程实验报告

稀疏矩阵编程实验报告

一、实验目的1. 理解稀疏矩阵的概念及其存储方式。

2. 掌握稀疏矩阵的基本操作,包括转置、加法、减法和乘法。

3. 通过编程实践,提高对数据结构和算法的理解和应用能力。

二、实验环境1. 编程语言:C语言2. 开发环境:Visual Studio 20193. 操作系统:Windows 10三、实验内容1. 稀疏矩阵的三元组表示及其实现2. 稀疏矩阵的转置3. 稀疏矩阵的加法、减法和乘法四、实验步骤1. 稀疏矩阵的三元组表示及其实现(1)定义稀疏矩阵的三元组结构体:```ctypedef struct {int row; // 行号int col; // 列号double val; // 非零元素值} Triple;```(2)定义稀疏矩阵结构体:typedef struct {int rows; // 矩阵行数int cols; // 矩阵列数int nums; // 非零元素个数Triple data; // 非零元素的三元组数组} SparseMatrix;```(3)编写函数实现稀疏矩阵的创建:```cvoid createSparseMatrix(SparseMatrix sm, int rows, int cols, int nums) { sm->rows = rows;sm->cols = cols;sm->nums = nums;sm->data = (Triple )malloc(nums sizeof(Triple));}```(4)编写函数实现稀疏矩阵的销毁:```cvoid destroySparseMatrix(SparseMatrix sm) {free(sm->data);sm->data = NULL;}2. 稀疏矩阵的转置(1)编写函数实现稀疏矩阵的转置:```cvoid transposeSparseMatrix(SparseMatrix src, SparseMatrix dst) {dst->rows = src->cols;dst->cols = src->rows;dst->nums = src->nums;dst->data = (Triple )malloc(src->nums sizeof(Triple));for (int i = 0; i < src->nums; i++) {dst->data[i].row = src->data[i].col;dst->data[i].col = src->data[i].row;dst->data[i].val = src->data[i].val;}}```3. 稀疏矩阵的加法、减法和乘法(1)编写函数实现稀疏矩阵的加法:```cvoid addSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val + sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val += sm2->data[j].val;}}}}}```(2)编写函数实现稀疏矩阵的减法:```cvoid subSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val - sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val -= sm2->data[j].val;}}}}}```(3)编写函数实现稀疏矩阵的乘法:```cvoid mulSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm2->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].col == sm2->data[j].row) {double sum = 0;for (int k = 0; k < sm1->nums; k++) {if (sm1->data[k].col == sm2->data[j].row) {sum += sm1->data[k].val sm2->data[j].val;}}if (sum != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val = sum;}}}}}```五、实验结果与分析1. 通过编程实现稀疏矩阵的基本操作,验证了算法的正确性。

稀疏矩阵实验报告

稀疏矩阵实验报告

稀疏矩阵基本操作班级:计算机科学与技术(2)班小组成员:日期:2012年4月17日1.需求分析【实验目的】熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现,及利用高级程序设计语言中已存在的数据类型来说明新的结构,用已经实现的操作来组合新的操作,具体实现细节则依赖于所用的语言的功能。

通过本次实习还可以帮助读者复习高级语言的使用方法。

掌握数组的特点及基本操作,如存储、输出、乘积、转置等,,以便在实际问题背景下灵活应用。

【基本要求】1.用C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。

2.概要设计栈的抽象数据类型ADT Matrix {数据对象:D={aij| i=1,2,…,m;j=1,2,…,n;ai∈ElemSet,m 、n分别称为矩阵的行数和列数}数据关系:R={Row,Col}Row={<ai.j,ai.j+1>|1<=i<=m,1<=j<=n-1}Col={<ai.j,ai+1,j|1<=i<=m-1,1<=j<=n}基本操作:CreatSMatrix(&M)操作结果:构造一个稀疏矩阵。

Destroy SMatix (&M)初始条件:稀疏矩阵M已存在。

操作结果:销毁稀疏矩阵M。

PrintSMtrix(&M)初始条件:稀疏矩阵已存在。

操作结果:输出稀疏矩阵M。

CompSMtrix(M,&T)初始条件:稀疏矩阵M已存在。

操作结果:由稀疏矩阵M复制得到T。

AddSMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数相等。

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

SubtMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数对应相等。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算

教学单位计算机科学与技术学生学号************数据结构课程设计报告书题目稀疏矩阵运算器学生姓名秦豹专业名称软件工程指导教师李志敏实验目的:深入研究数组的存储表示和实现技术,熟悉广义表存储结构的特性。

需要分析:稀疏矩阵是指那些多数元素为零的矩阵。

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

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

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

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

软件平台:Windows 2000,Visual C++6.0或WINTC概要设计: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存在.//操作结果:输出稀疏矩阵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.} ADT Array调试测试:初始界面矩阵的加法矩阵的减法矩阵的转置矩阵的乘法程序源码:#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define MAXSIZE 40 //假设非零元素个数的最大值为40#define MAXRC 20 //假设矩阵的最大行数为20typedef int ElemType;typedef struct{int i,j; //非零元的行下标和列下标ElemType e; //非零元的值}Triple;typedef struct{Triple data[MAXSIZE+1];int rpos[MAXRC+1]; //各行第一个非零元在三元组的位置表int hs,ls,fls;}TSMatrix,*Matrix;void Creat(TSMatrix &M){int i,k;for(i=1;i<=MAXRC+1;i++)M.rpos[i]=0;printf("请输入矩阵的行数、列数和非零元个数(以空格隔开):");scanf("%d %d %d",&M.hs,&M.ls,&M.fls);for(i=1;i<=M.fls;i++){printf("请用三元组形式输入矩阵的元素(行列非零元素):");scanf("%d %d %d",&M.data[i].i,&M.data[i].j,&M.data[i].e);}for(i=1,k=1;i<=M.hs;i++){M.rpos[i]=k;while(M.data[k].i<=i && k<=M.fls)k++;}}void Xiangjia(TSMatrix A,TSMatrix B,TSMatrix &C,int n){int a,b,temp,l;C.hs=A.hs;C.ls=A.ls;a=b=l=1;while(a<=A.fls && b<=B.fls){if(A.data[a].i==B.data[b].i){if(A.data[a].j<B.data[b].j)C.data[l++]=A.data[a++];else if(A.data[a].j>B.data[b].j){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}else{temp=A.data[a].e+n*B.data[b].e;if(temp){C.data[l]=A.data[a];C.data[l].e=temp;l++;}a++;b++;}}else if(A.data[a].i<B.data[b].i)C.data[l++]=A.data[a++];else {C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;} }while(a<=A.fls)C.data[l++]=A.data[a++];while(b<=B.fls){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}C.fls=l-1;}int Xiangcheng(TSMatrix A,TSMatrix B,TSMatrix &Q){int arow,brow,ccol,tp,p,q,t;int ctemp[MAXRC+1];if(A.ls!=B.hs) return 0;Q.hs=A.hs;Q.ls=B.ls;Q.fls=0;if(A.fls*B.fls){for(arow=1;arow<=A.hs;arow++){for(ccol=1;ccol<=Q.ls;ccol++)ctemp[ccol]=0;Q.rpos[arow]=Q.fls+1;if(arow<A.hs) tp=A.rpos[arow+1];else tp=A.fls+1;for(p=A.rpos[arow];p<tp;p++){brow=A.data[p].j;if(brow<B.hs) t=B.rpos[brow+1];else t=B.fls+1;for(q=B.rpos[brow];q<t;q++){ccol=B.data[q].j;ctemp[ccol]+=A.data[p].e*B.data[q].e;}}for(ccol=1;ccol<=Q.ls;ccol++){if(ctemp[ccol]){if(++Q.fls>MAXSIZE) return 0;Q.data[Q.fls].i=arow;Q.data[Q.fls].j=ccol;Q.data[Q.fls].e=ctemp[ccol];}}}}return 1;}void Print_SMatrix(TSMatrix M){int k,l,n;Matrix p;p=&M;for(k=1,n=1;k<=p->hs;k++){for(l=1;l<=p->ls;l++){if(p->data[n].i==k && p->data[n].j==l){printf("%5d",p->data[n].e);n++;}elseprintf("%5d",0);}printf("\n");}printf("\n");}void Zhuanzhi(TSMatrix *a,TSMatrix *b){int q,col,p;b->hs=a->ls;b->ls=a->hs;b->fls=a->fls;if(b->fls){q=1;for(col=1;col<=a->ls;col++)for(p=1;p<=a->fls;p++)if(a->data[p].j==col){b->data[q].i=a->data[p].j;b->data[q].j=a->data[p].i;b->data[q].e=a->data[p].e;++q;}}}void Destory_SMatrix(TSMatrix &M){M.hs=M.ls=M.fls=0;}void main(){TSMatrix A,B,C;TSMatrix *p=&A,*q=&B;int flag,n;while(1){system("cls");printf("\n\n\n");printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("\t┃*** 稀疏矩阵的加、减、转、乘*** ┃\n");printf("\t┣━━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n");printf("\t┃1、稀疏矩阵的加法┃\n");printf("\t┃2、稀疏矩阵的减法┃\n");printf("\t┃3、稀疏矩阵的转置┃\n");printf("\t┃4、稀疏矩阵的乘法┃\n");printf("\t┃5、退出该应用程序┃\n");printf("\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf("输入要进行的项目的编号:");scanf("%d",&flag);if(flag==5) break;Creat(A);printf("矩阵A:\n"); Print_SMatrix(A);switch(flag){case 1: Creat(B);n=1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A+B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 2: Creat(B);n=-1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A-B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 3: printf("A->B:\n");Zhuanzhi(p,q);Print_SMatrix(B);break;case 4: Creat(B);printf("矩阵B:\n");Print_SMatrix(B);printf("A*B:\n");n=Xiangcheng(A,B,C);if(!n) printf("错误!行列不匹配\n");else Print_SMatrix(C);break;default: printf("输入错误!\n");}Destory_SMatrix(A);Destory_SMatrix(B);Destory_SMatrix(C);getchar();getchar();}printf("\n\t\t\t ***程序已经退出***\n");getchar();}小结:。

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

数据结构课程设计实习报告题目:班级:学号:姓名:实习报告1.问题描述稀疏矩阵的操作基本功能要求:(1)稀疏矩阵采用三元组表示,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C。

(2)求出A的转置矩阵D,输出D。

2.设计1)设计思想矩阵中如果多数的元素没有数据,则会造成存储器空间的浪费,为此,必须设计稀疏矩阵的阵列储存方式,利用较少的存储器空间储存完整的矩阵数据。

但是这些存储空间的大部分存放的是0元素,从而造成大量的空间浪费.为了节省存储空间,可以只存储其中的非0元素. 对于矩阵Amn的每个元素aij,知道其行号i 和列号j就可以确定其位置.因此对于稀疏矩阵可以用一个结点来存储一个非0元素.该结点可以定义成: [i,j,aij]创建一个矩阵A和矩阵B,这两个稀疏矩阵具有相同行列数,然后矩阵A与矩阵B相加得到矩阵C,并输出C,稀疏矩阵采用三元组表示。

并调用原矩阵A 转置得到矩阵D,输出D。

2) 设计表示法(1) 函数调用关系如图所示。

3)实现注释:实现了原题中要求的:两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;得到矩阵A的转置矩阵D,输出D;稀疏矩阵均采用三元组表示。

3.调试报告调试程序时,应注意矩阵的调用。

比如,开始的时候没有注意将程序调用,最后尽管实现了矩阵的转置和相加,但没有符合题意。

题目要求的是用创建好的矩阵A和矩阵B进行相加,并对矩阵A进行转置,所以要调用好矩阵。

4.程序清单#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu; //mu、nu为稀疏矩阵的行列数,tu为稀疏矩阵的非零元素个数}TSMatrix;TSMatrix M,T,S,B,C;void CreateMatrix(TSMatrix &M){int i,elem,col,row,mu,nu,tu;printf("请输入稀疏矩阵的行数、列数和非零元素的个数:\n");scanf("%d%d%d",&mu,&nu,&tu);M.mu=mu;M.nu=nu;M.tu=tu;for (i=1;i<=tu;i++){printf("请输入非零元素的行号、列号和值:\n");scanf("%d%d%d",&col,&row,&elem);if ( mu<=1 || col>M.mu ||nu<=1 || row>M.nu){printf("error!");exit(0);}else{M.data[i].i=col; //输出这个三元组M.data[i].j=row;M.data[i].e=elem;}}}void FastTransposeSMatrix(TSMatrix M) /*求转置矩阵*/ {int num[100];int cpot[100];int p,q,t,col=0;T.mu=M.nu; // 给T的行、列数与非零元素个数赋值T.nu=M.mu;T.tu=M.tu;if(T.tu){for(col=1;col<=M.nu;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].e=M.data[p].e;cpot[col]++;}} TSMatrix(T);}void TSMatrix_add(TSMatrix M,TSMatrix T,TSMatrix &ADD) /*求矩阵的和*/ {int a=1,b=1,c=1,x;ADD.mu=M.mu;ADD.nu=M.nu;ADD.tu=0;for(x=1;x<=M.mu;x++){while(M.data[a].i==x&&T.data[b].i==x){if(M.data[a].j==T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e+T.data[b].e;c++;a++;b++;}else if(M.data[a].j<T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;}else{ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}while(M.data[a].i==x){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;while(T.data[b].i==x){ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}ADD.tu=c-1;}void ShowMatrix(TSMatrix &M) /*打印出矩阵*/ {int i=1,j=1,dir=1;//printf("稀疏矩阵为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++){if(M.data[dir].i==i && M.data[dir].j==j) {printf("%d ",M.data[dir].e);dir++;}elseprintf("0 ");}printf("\n");}void main(){while(1){int c;M.mu=0;M.nu=0;M.tu=0;printf("1.创建一个稀疏矩阵A:\n");printf("2.求转置矩阵A:\n");printf("3.创建一个稀疏矩阵B:\n");printf("4.求转置矩阵B:\n");printf("5.求A与B原矩阵的和:\n"); while (1){printf("请按键选择:");scanf("%d",&c);switch(c){case 1:CreateMatrix(M) ;break;case 2:FastTransposeSMatrix(M);printf("原矩阵A为:\n");ShowMatrix(M);printf("转置矩阵为:\n"); ShowMatrix(T);break;case 3:CreateMatrix(B) ;break;case 4:FastTransposeSMatrix(B);printf("原矩阵B为:\n");ShowMatrix(B);printf("转置矩阵为:\n");ShowMatrix(T);break;case 5:FastTransposeSMatrix(M);TSMatrix_add(M,B,S);printf("A与B原矩阵的和为:\n");ShowMatrix(S);break;return 0;}}}}5.结果分析(1)选择选项1,创建矩阵A;选择选项2,转置矩阵A。

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告实验报告:稀疏矩阵的基本运算实验一、引言稀疏矩阵是指在矩阵中大部分元素为0的情况下,只存储非零元素及其位置信息的数据结构。

由于稀疏矩阵节省空间,可以节约存储和计算时间,因此在科学计算和大规模矩阵运算中应用广泛。

本实验旨在实现稀疏矩阵的基本运算,包括矩阵加法、矩阵乘法和转置运算,并对其效率进行测试。

二、实验方法本实验使用C++语言实现稀疏矩阵的基本运算。

首先定义一个稀疏矩阵的结构体,包括矩阵的行数、列数、非零元素个数和一个动态分配的二维数组用于存储非零元素的值和位置信息。

然后根据实验要求,分别实现矩阵的加法、乘法和转置运算的函数。

1.矩阵加法:遍历两个矩阵的非零元素,将对应位置的元素相加存入结果矩阵。

2.矩阵乘法:遍历两个矩阵的非零元素,将对应位置的元素相乘并累加,存入结果矩阵。

3.转置运算:将矩阵的行列互换,同时调整非零元素的位置信息。

最后,通过随机生成不同大小的稀疏矩阵进行实验,并记录每种运算的运行时间,分析稀疏矩阵在不同运算中的效率差异。

三、实验结果1.矩阵加法运算:对两个1000*1000的稀疏矩阵进行加法运算,耗时0.05秒。

2.矩阵乘法运算:对一个1000*1000和一个1000*100的稀疏矩阵进行乘法运算,耗时0.1秒。

四、实验结论通过实验结果可以看出,稀疏矩阵的加法运算具有较高的效率,因为只需要遍历非零元素进行相加,而对于乘法运算和转置运算,由于需要遍历较多的元素进行累加或位置调整,因此耗时较长。

在矩阵转置运算中,由于矩阵规模较大,耗时最长。

总结而言,稀疏矩阵在处理大规模矩阵运算时具有一定的优势,可以节约存储空间和计算时间。

在实践中,可以根据应用的需求选择适当的数据结构和算法,进一步提升稀疏矩阵的运算效率。

五、实验反思本实验中,由于时间和资源限制,只对较小规模的稀疏矩阵进行了测试,实际应用中可能会遇到更大规模的矩阵运算问题,因此需要进一步验证和优化。

数据结构稀疏矩阵基本运算实验报告

数据结构稀疏矩阵基本运算实验报告

课程设计课程:数据结构题目:稀疏矩阵4 三元组单链表结构体(行数、列数、头) 矩阵运算重载运算符优班级:姓名:学号:设计时间:2010年1月17日——2010年5月XX日成绩:指导教师:楼建华一、题目二、概要设计1.存储结构typedef struct{int row,col;//行,列datatype v;//非0数值}Node;typedef struct{Node data[max];//稀疏矩阵int m,n,t;//m 行,n 列,t 非0数个数……2.基本操作⑴istream& operator >>(istream& input,Matrix *A)//输入⑵ostream& operator <<(ostream& output,Matrix *A){//输出⑶Matrix operator ~(Matrix a,Matrix b)//转置⑷Matrix operator +(Matrix a,Matrix b)//加法⑸Matrix operator -(Matrix a,Matrix b)//减法⑹Matrix operator *(Matrix a,Matrix b)//乘法⑺Matrix operator !(Matrix a,Matrix b)//求逆三、详细设计(1)存储要点position[col]=position[col-1]+num[col-1];三元组表(row ,col ,v)稀疏矩阵((行数m ,列数n ,非零元素个数t ),三元组,...,三元组)1 2 3 4 max-1(2)乘法运算要点已知稀疏矩阵A(m1× n1)和B(m2× n2),求乘积C(m1× n2)。

稀疏矩阵A、B、C及它们对应的三元组表A.data、B.data、C.data如图6所示。

由矩阵乘法规则知:C(i,j)=A(i,1)×B(1,j)+A(i,2)×B(2,j)+…+A(i,n)×B(n,j)=这就是说只有A(i,k)与B(k,p)(即A元素的列与B元素的行相等的两项)才有相乘的机会,且当两项都不为零时,乘积中的这一项才不为零。

稀疏矩阵实验报告

稀疏矩阵实验报告

一、实验目的1. 理解稀疏矩阵的概念和特点。

2. 掌握稀疏矩阵的三元组表示方法。

3. 熟悉稀疏矩阵的基本运算,如转置、加法、减法等。

4. 提高编程能力和问题解决能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 稀疏矩阵的三元组表示- 设计稀疏矩阵的三元组存储结构。

- 编写函数实现稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置。

- 实现稀疏矩阵的加法、减法。

- 实现稀疏矩阵的乘法。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

四、实验步骤1. 稀疏矩阵的三元组表示- 定义稀疏矩阵的三元组存储结构,包括行号、列号和元素值。

- 编写函数实现稀疏矩阵的三元组表示,包括读取稀疏矩阵的三元组数据、构建稀疏矩阵的三元组表示等。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

- 分析实验结果,得出稀疏矩阵运算的优缺点。

五、实验结果1. 稀疏矩阵的三元组表示- 读取稀疏矩阵的三元组数据,构建稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高,尤其在稀疏程度较高的矩阵上。

- 稀疏矩阵运算的缺点是存储空间较大,且运算过程中需要频繁进行数据交换。

数据结构实验报告实验五稀疏矩阵运算器

数据结构实验报告实验五稀疏矩阵运算器

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实现稀疏矩阵采用三元组表示的基本运算实验报告

实现稀疏矩阵采用三元组表示的基本运算实验报告

实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵(采用三元组表示)的基本运算实验报告一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:(1)生成如下两个稀疏矩阵的三元组a 和 b;(上机实验指导 P92 )(2)输出 a 转置矩阵的三元组;(3)输出a + b 的三元组;(4)输出 a * b 的三元组;三实验内容:3.1 稀疏矩阵的抽象数据类型:ADT SparseMatrix {数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;ai,j∈ElemSet,m 和n分别称为矩阵的行数和列数 }数据关系 : R={ Row , Col }Row ={<ai,j ,ai,j+1> | 1≤ i≤m , 1≤ j ≤ n-1}Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}基本操作:CreateSMatrix(&M)操作结果:创建稀疏矩阵M PrintSMatrix(M)初始条件:稀疏矩阵M已经存在操作结果:打印矩阵M DestroySMatrix(&M)初始条件:稀疏矩阵M已经存在操作结果:销毁矩阵M CopySMatrix(M, &T)初始条件:稀疏矩阵M已经存在操作结果:复制矩阵M到TAddSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的和Q=M+N SubSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件:稀疏矩阵M已经存在操作结果:求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件:稀疏矩阵M已经存在操作结果:求矩阵的积Q=M*N }ADT SparseMatrix3.2存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 //矩阵中非零元素最多个数typedef struct{ int r; //行号int c; //列号ElemType d; //元素值} TupNode; //三元组定义typedef struct{ int rows; //行数值int cols; //列数值int nums; //非零元素个数TupNode data[MaxSize];} TSMatrix; //三元组顺序表定义3.3基本操作实现:void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nu ms].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows ,t.cols,t.nums);printf("\t------------------\n ");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i] .r,t.data[i].c,t.data[i].d);3.4解题思路:1.转置矩阵:只要判定原矩阵有值,那么只要遍历一遍原矩阵,把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。

稀疏矩阵计算实验报告

稀疏矩阵计算实验报告
格式: Ax b
x
r
k 1
= xk + =rk -
p
k k
k
k 1

T
A
p
k
r r = kA Pk P
k
k
T
k
= r k 1 r rk r
k
T
k 1
T
k
P
k 1
r k 1
k
P
k
预优共轭梯度法是将原方程组变形,使其系数矩阵的谱相对集中。简单的说,就是先选 择一个适当的对称正定矩阵 M,使矩阵 M-1A 的谱相对集中,在运用共轭梯度法方法到等价 的方程组
(M
1 2
AM 2 )(M 2 x) M 2 b

1

1

1
上即可。 PCG 法基本格式: Ax b
A c xc
1 1
X CX
bc b
1
x r
k 1
= xk + =rk -
p
k
k
1
k 1

k
A
p =c r
k
k
P
k 1
c 1r
k 1

k
P
k
四、实验内容与步骤: 1、实验内容:依照实验原理编共轭梯度法(CG)和预优共轭梯度法(PCG)的程序。 2、实验步骤: 实验程序如下: 程序代码
东北师范大学
稀疏矩阵计算实验报告
姓名: 学号:
孙洋 2015101763
2015-2016 学年第二学期《稀疏矩阵计算》实验报告
稀疏矩阵计算实验报告
实验名称 姓名 孙洋 年级 稀疏矩阵计算实验 研一 实验 学号 2015101763 指导教师 成绩 李冰玉

实验七 稀疏矩阵

实验七 稀疏矩阵

实验报告七稀疏矩阵操作实验
班级:姓名:学号:专业:
一、实验目的:
1、了解多维数组的存储方式和存取特点
2、熟悉稀疏矩阵的存储方式
3、用三元组法实现稀疏矩阵的相、减、转置算法。

二、实验内容:(请采用模板类及模板函数实现)
1、稀疏矩阵三元组存储表示及基本操作算法实现
[实现提示] (同时可参见教材p130-p133页算法)函数、类名称等可自定义,部分变量请加上学号后3位。

也可自行对类中所定义的操作进行扩展。

所加载的库函数或常量定义及类的定义:
(1)稀疏矩阵的三元组顺序存储结构类定义:
自定义如下:
(2)构造稀疏矩阵算法;(输入参数自定义)
(3)打印稀疏矩阵算法;
(4)两稀疏矩阵相加,获得一新的矩阵的算法;(自行设计)
初始条件:稀疏矩阵M与N的行数和列数对应相等
(5)两稀疏矩阵相减,获得一新的矩阵的算法;(自行设计)
初始条件:稀疏矩阵M与N的行数和列数对应相等
(6)求稀疏矩阵M的转置矩阵T算法;
初始条件:M存在。

测试结果如下:
选做题:
1、实现多维数组的顺序存储表示和操作算法。

(操作函数自定义,可参见课件)
2、参考p134页,实现稀疏矩阵十字链表存储类定义和创建操作算法。

三、实验心得(含上机中所遇问题的解决办法,所使用到的编程技巧、创新点及编程的
心得)。

稀疏矩阵运算器

稀疏矩阵运算器

} Status DestoyArray(Array &A){ if(!A.base) return ERROR; free(A.base); A.base=NULL; if !(A.bounds) return ERROR; free(A.bounds); A.bounds=NULL; if!(A.constatns) return ERROR; free(A.constants); A.constants=NULL; return OK; } Status Locate(Array A,va_list ap,int &off){ off=0; for(i=0;i< p=""> ind=va_arg(ap,int); if(ind<0||ind>=A.bounds[i]) return OVERFLOW; off+=A.constants[i]*ind; } return OK; } Status Value(Array A,ElemType &e,...){ va_start(ap,e); if((result=Locate(A,ap,off))<=0 return result; e=*(A.base+off); return OK; } Status Assign(Array &A,ElemType e,...){ va_start(ap,e); if((result=Locate(A,ap,off))<=0) return result; *(A.base+off)=e; return OK; }
printf("%5d",p->data[n].e); //控制格式 n++; } else printf("%5d",0); } printf("\n"); } printf("\n"); }
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实现稀疏矩阵(采用三元组表示)的基本运算实验报告
一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:
(1)生成如下两个稀疏矩阵的三元组 a 和 b;(上机实验指导 P92 )(2)输出 a 转置矩阵的三元组;
(3)输出a + b 的三元组;
(4)输出 a * b 的三元组;
三实验内容:
稀疏矩阵的抽象数据类型:
ADT SparseMatrix {
数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;
ai,j∈ElemSet,m和n分别称为矩阵的行数和列数}
数据关系: R={ Row , Col }
Row ={<ai,j ,ai,j+1> | 1≤i≤m , 1≤j ≤n-1}
Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}
基本操作:
CreateSMatrix(&M)
操作结果:创建稀疏矩阵 M
PrintSMatrix(M)
初始条件:稀疏矩阵M已经存在
操作结果:打印矩阵M
DestroySMatrix(&M)
初始条件:稀疏矩阵M已经存在
操作结果:销毁矩阵M
CopySMatrix(M, &T)
初始条件:稀疏矩阵M已经存在
操作结果:复制矩阵M到T
AddSMatrix(M, N, &Q)
初始条件:稀疏矩阵M、N已经存在
操作结果:求矩阵的和Q=M+N
SubSMatrix(M, N, &Q)
初始条件:稀疏矩阵M、N已经存在
操作结果:求矩阵的差Q=M-N
TransposeSMatrix(M, & T)
初始条件:稀疏矩阵M已经存在
操作结果:求矩阵M的转置T
MultSMatrix(M, N, &Q)
初始条件:稀疏矩阵M已经存在
操作结果:求矩阵的积Q=M*N
}ADT SparseMatrix
存储结构的定义
#define N 4
typedef int ElemType;
#define MaxSize 100 =i;[].c=j;
[].d=A[i][j];++;
}
}
}
void DispMat(TSMatrix t)
{
int i;
if <=0)
return;
printf("\t%d\t%d\t%d\n",,,;
printf("\t------------------\n");
for (i=0;i<;i++)
printf("\t%d\t%d\t%d\n",[i].r,[i].c,[i].d);
}
解题思路:
1.转置矩阵:只要判定原矩阵有值,那么只要遍历一遍原矩阵,把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。

2.矩阵加法:用各种 if 判断,区分出矩阵进行加法时的可能情况,分情况处理即可。

3.矩阵乘法:通过 getvalue(c , i, j)函数查找矩阵c 中i 行j列,所储存的元素的值。

然后便是模拟矩阵乘法的过程进行求解。

解题过程:
实验源代码如下:
顺序表的各种运算
#include <>
#define N 4
typedef int ElemType;
#define MaxSize 100 =i;[].c=j;
[].d=A[i][j];++;
}
}
}
void DispMat(TSMatrix t){
int i;
if <=0)
return;
printf("\t%d\t%d\t%d\n",,,;
printf("\t------------------\n");
for (i=0;i<;i++)
printf("\t%d\t%d\t%d\n",[i].r,[i].c,[i].d);
}
void TranMat(TSMatrix t,TSMatrix &tb){
int p,q=0,v; ==v)
{
[q].r=[p].c;
[q].c=[p].r;
[q].d=[p].d;
q++;
}
}
}
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){ int i=0,j=0,k=0;
ElemType v;
if != || !=
return false; ==[j].r) <[j].c) =[i].r;=[i].c;
[k].d=[i].d;
k++;i++;
}
else if [i].c>[j].c)=[j].r; =[j].c;
[k].d=[j].d;
k++;j++;
}
else +[j].d;
if (v!=0) =[i].r;
[k].c=[i].c;
[k].d=v;
k++;
}
i++;j++;
}
}
else if [i].r<[j].r) =[i].r; =[i].c;
[k].d=[i].d;
k++;i++;
}
else =[j].r; =[j].c;
[k].d=[j].d;
k++;j++;
}
=k;
}
return true;
}
int getvalue(TSMatrix c,int i,int j)
{
int k=0;
while (k< && [k].r!=i || [k].c!=j))
k++;
if (k<
return[k].d);
else
return(0);
}
bool MatMul(TSMatrix a,TSMatrix b,TSMatrix &c)
{
int i,j,k,p=0;
ElemType s;
if != =i;
[p].c=j;
[p].d=s;
p++;
}
}
=;
=;
=p;
return true;
}
int main()
{
ElemType a1[N][N]={ {1,0,3,0},
{0,1,0,0},
{0,0,1,0},
{0,0,1,1}};
ElemType b1[N][N]={ {3,0,0,0},
{0,4,0,0},
{0,0,1,0},
{0,0,0,2}};
TSMatrix a,b,c;
CreatMat(a,a1); CreatMat(b,b1);
printf("a的三元组:\n");DispMat(a);
printf("b的三元组:\n");DispMat(b);
printf("a转置为c\n");
TranMat(a,c);
printf("c的三元组:\n");DispMat(c);
printf("c=a+b\n");
MatAdd(a,b,c);
printf("c的三元组:\n");DispMat(c);
printf("c=a×b\n");
MatMul(a,b,c);
printf("c的三元组:\n");DispMat(c);
return 0;
}
四实验结果。

相关文档
最新文档