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

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的矩阵。
在实际问题中,有许多矩阵具有稀疏性,例如文本矩阵、图像矩阵等。
由于存储稀疏矩阵时,对于大量的零元素进行存储是一种浪费空间的行为,因此需要采用一种特殊的存储方式。
常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。
其中,三元组顺序表是最简单直观的一种方式,它是将非零元素按行优先的顺序存储起来,每个元素由三个参数组成:行号、列号和元素值。
此外,还需要记录稀疏矩阵的行数、列数和非零元素个数。
稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历,对于相同位置的元素进行相加,得到结果矩阵。
稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算,即行乘以列的和。
实验步骤:1.实现稀疏矩阵的三元组顺序表存储方式,并完成稀疏矩阵的初始化、转置、打印等基本操作。
2.实现稀疏矩阵的加法运算,并进行性能测试和分析。
3.实现稀疏矩阵的乘法运算,并进行性能测试和分析。
4.编写实验报告。
实验结果:经过实验测试,稀疏矩阵的加法和乘法算法都能正确运行,并且在处理稀疏矩阵时能够有效节省存储空间。
性能测试结果表明,稀疏矩阵加法、乘法的运行时间与非零元素个数有关,当非零元素个数较少时,运算速度较快;当非零元素个数较多时,运算速度较慢。
实验分析:稀疏矩阵的运算相对于普通矩阵的运算有明显的优势,可以节省存储空间和运算时间。
在实际应用中,稀疏矩阵的存储方式和运算算法都可以进行优化。
例如,可以采用行逻辑链接表的方式存储稀疏矩阵,进一步减少存储空间的占用;可以采用并行计算的策略加快稀疏矩阵的运算速度。
总结:通过本次实验,我深入学习了稀疏矩阵的概念、特点和存储方式,掌握了稀疏矩阵加法、乘法的基本思想和算法,并通过实验实现了稀疏矩阵的加法、乘法运算。
稀疏矩阵运算器实习报告

数据结构实验报告数组和广义表题目:稀疏矩阵运算器物联网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.进入演示程序后即显示文本方式的用户界面:。
实验报告五:稀疏矩阵的三元组实现实验

实验报告
实验五稀疏矩阵的三元组实现实验(4学时)
实验目的:
掌握稀疏矩阵的三元组表示方法、算法实现。
实验内容:(类C算法的程序实现,任选其二)
(1) 基于三元组的稀疏矩阵表示与输入、输出方法(必做);
(2) 基于三元组的稀疏矩阵加法(选做);
(3) 基于三元组表示的稀疏矩阵转置(选做);
(4) 基于三元组表示的稀疏矩阵的乘法(选做)。
实验准备:
1) 计算机设备;2) 程序调试环境的准备,如TC环境;3) 实验内容的算法分析与代码设计与分析准备。
实验步骤:
1.录入程序代码并进行调试和算法分析;
2.编写实验报告。
实验结果:
试验的完整的C程序代码,以及程序实现与结果分析。
源程序:
1,三元组的顺序表存储表示
2,创建一个稀疏矩阵
3,表示这个矩阵
4,主函数
最终结果:。
稀疏矩阵编程实验报告

一、实验目的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. 通过编程实现稀疏矩阵的基本操作,验证了算法的正确性。
稀疏矩阵的转置实训报告

#### 一、实训背景稀疏矩阵在计算机科学和工程领域中有着广泛的应用,特别是在处理大规模数据时,由于其数据压缩的特性,可以显著降低存储空间和计算时间。
稀疏矩阵的转置是稀疏矩阵处理中的一个基本操作,对于理解稀疏矩阵的性质和进行后续的矩阵运算至关重要。
本实训旨在通过实现稀疏矩阵的转置功能,加深对稀疏矩阵数据结构和操作的理解。
#### 二、实训目标1. 理解稀疏矩阵的概念和特点。
2. 掌握稀疏矩阵的三元组表示方法。
3. 实现稀疏矩阵的转置操作。
4. 分析转置操作的算法复杂度。
5. 对比不同转置算法的性能。
#### 三、实训内容1. 稀疏矩阵的三元组表示稀疏矩阵的三元组表示法通过三元组(i, j, e)来存储非零元素,其中i和j分别表示行和列的索引,e表示对应的元素值。
这种方法能够有效地压缩存储空间。
2. 稀疏矩阵的转置稀疏矩阵的转置操作涉及到交换行和列的索引。
具体步骤如下:- 遍历原稀疏矩阵中的所有非零元素。
- 对于每个非零元素(i, j, e),将其存储为(j, i, e)并添加到转置矩阵中。
3. 算法实现使用C++语言实现稀疏矩阵的转置,主要包括以下步骤:- 定义稀疏矩阵的数据结构。
- 实现转置函数。
- 测试转置函数的正确性和效率。
4. 性能分析分析不同转置算法的时间复杂度和空间复杂度,对比不同实现方式的性能。
#### 四、实训过程1. 数据结构设计使用结构体来定义稀疏矩阵的三元组,包括行索引、列索引和元素值。
同时,定义一个数组来存储所有的三元组。
2. 转置函数实现实现一个转置函数,该函数接收一个稀疏矩阵的三元组数组,返回一个新的三元组数组,表示转置后的稀疏矩阵。
3. 测试编写测试代码,创建一个稀疏矩阵实例,调用转置函数,并验证转置后的矩阵是否正确。
4. 性能测试使用不同的稀疏矩阵实例进行性能测试,比较不同实现方式的效率。
#### 五、实训结果与分析1. 结果通过实训,成功实现了稀疏矩阵的转置功能,并验证了其正确性。
稀疏矩阵基本操作 实验报告

稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵的压缩储存结构,以及稀疏矩阵的三元组表表示方法下的转置、相加、相乘等算法二、实验目的1.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义,掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素(三元组分别储存非零元素的行下标,列下标和元素值)。
除了三元组表本身,储存一个稀疏矩阵还需要额外的三个变量,分别储存矩阵的非零元个数,矩阵的行数和矩阵的列数。
2.稀疏矩阵的创建算法:第一步:根据矩阵创建一个二维数组,表示原始矩阵第二步:取出二维数组中的元素(从第一个元素开始取),判断取出元素是否为非零元素,如果为非零元素,把该非零元素的数值以及行下标和列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。
第三步:重复第二步,知道二维数组中所有的元素已经取出。
3.稀疏矩阵倒置算法:第一步:判断进行倒置的矩阵是否为空矩阵,如果是,则直接返回错误信息。
第二步:计算要倒置的矩阵每列非零元素的数量,存入到num数组(其中num[i] 代表矩阵中第i列非零元素的个数)。
以及倒置后矩阵每行首非零元的位置,存入cpot 数组中(其中cpot表示倒置后矩阵每行非零元的位置,对应表示原矩阵每列中第一个非零元的位置)。
第三步:确定倒置后矩阵的行数和列数。
第四步:取出表示要导致矩阵中三元组表元素{e, I, j}(第一次取出第一个,依次取出下一个元素),从第二步cpot数组中确定该元素倒置后存放的位置(cpot[j]),把该元素的行下标和列下标倒置以后放入新表的指定位置中。
cpot[j] 变量加一。
第五步:重复第四步,直到三元组表中所有的元素都完成倒置。
第六步:把完成倒置运算的三元组表输出。
4.稀疏矩阵加法算法:第一步:检查相加两个矩阵的行数和列数是否相同,如果相同,则进入第二步,否则输出错误信息。
第二步:定义变量i和j,用于控制三元组表的遍历。
稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

数据结构课程设计实习报告题目:班级:学号:姓名:实习报告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秒。
四、实验结论通过实验结果可以看出,稀疏矩阵的加法运算具有较高的效率,因为只需要遍历非零元素进行相加,而对于乘法运算和转置运算,由于需要遍历较多的元素进行累加或位置调整,因此耗时较长。
在矩阵转置运算中,由于矩阵规模较大,耗时最长。
总结而言,稀疏矩阵在处理大规模矩阵运算时具有一定的优势,可以节约存储空间和计算时间。
在实践中,可以根据应用的需求选择适当的数据结构和算法,进一步提升稀疏矩阵的运算效率。
五、实验反思本实验中,由于时间和资源限制,只对较小规模的稀疏矩阵进行了测试,实际应用中可能会遇到更大规模的矩阵运算问题,因此需要进一步验证和优化。
课程设计实验报告 稀疏矩阵应用

数据结构课程设计《数据结构》课程设计一.题目:稀疏矩阵应用(限1 人完成)要求:实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。
(1)稀疏矩阵的存储(2)稀疏矩阵加法(3)矩阵乘法(4)矩阵转置二.算法思想描述:1.需求分析(1)设计函数建立稀疏矩阵,初始化值。
(2)设计函数输出稀疏矩阵的值。
(3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。
(4)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。
(5)构造函数进行稀疏矩阵的转置,并输出结果。
(6)退出系统。
1.算法概述:首先用两个结构体来定义十字链表元素:typedef struct OLNode{int i,j;int e;struct OLNode *right,*down;}OLNode,*OLink;OLNode结构为链表结点,i,j,e分别表示稀疏矩阵中元素的行,列和值。
typedef struct {int mu,nu,tu; //行数mu,列数nu,非零元素的个数tuOLink *rhead,*chead;}CrossList;CrossList结构用于连接起各个结点,mu,nu,tu分别表示整个矩阵的行数列数和非零元素的个数。
整个程序包含CreateSMatix_OL(用于创建十字链表),SMatrix_ADD(十字链表相加),ShowMAtrix(十字链表显示),MultSMatrix_OL(十字链表相乘),TurnSMatrix_OL(十字链表转置),DestroySMatrix_OL(十字链表销毁)六个函数。
CreateSMatix_OL的功能如下:首先输入稀疏矩阵的行数,列数,非零元素的个数,为*rhead和*chead分配内存空间,并将十字链表中节点初始化为NULL。
然后依次输入非零元素的行,列,值,以0 0 0为结尾结束链表的连接和while循环。
SMatrix_ADD 的功能如下:在初始化稀疏矩阵后选择十字链表相加会提示输入另一个稀疏矩阵,连接结束后SMatrix_ADD 函数以循环的方式比较非零元素是否为同一行列,如果是则两值相加,如果不是则把第二个元素加入链表中。
基于三元组表的存储结构实现稀疏矩阵的应用课程设计,实验报告

基于三元组表的存储结构实现稀疏矩阵的应用课程设计,实验报告数据结构课程设计设计题目:基于三元组表的存储结构实现稀疏矩阵的应用学生姓名: 专业班级: 指导教师: 完成时间:信息工程学院信科系课程设计成绩评定表(本科)课题名称基于三元组表的存储结构实现稀疏矩阵的基本操作院系年级专业学号姓名成绩1、课题设计目的:(1)掌握稀疏矩阵三元组表的存储、创建、显示、转置。
(2)利用三元组表实现矩阵的相加、减。
(3)了解稀疏矩阵的相关应用。
2、课题设计意义:本次课题设计可以使我们更熟练的掌握有关三元组表及稀疏课题设计矩阵的相关知识,比一般存储方法节省了存储空间,基于三元组表目的与的存储结构实现了稀疏矩阵的基本操作。
设计意义本次课程设计是本组成员共同努力而完成的,第一次进行课程设计是我们的探索过程,这个过程中,我们克服了一个个困难,在摸索中前行,我们相信通过此次课程设计我们每个人都会对数据结构这门课程有更深一步的了解。
指导教师:年月日目录一、课题设计目的及意义 ............................................11.1、课题设计目的 (1)1.2、课程设计意义 (1)二、需求分析 (1)2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值 (1)2.2 构造函数进行稀疏矩阵的转置并输出结果 (1)2.3 构造函数进行两稀疏矩阵相加、减及相乘并输出最终稀疏矩阵 (1)2.4 退出系统 (2)三、项目设计 (2)3.1结构设计 (2)3.2算法思想 (2)3.3模块图 (2)3.4流程图 (3)四、系统实现 (4)4.1主调函数 (4)4.2三元组表建立 (4)4.3矩阵建立 (4)4.4矩阵相加减及转置 (5)五、系统调试 (8)5.1主菜单输出 (8)5.2矩阵相加 (9)5.3矩阵转置 (9)5.4矩阵相减 (10)六、实验总结 (10)七、附录 (11)一、课题设计目的及意义1.1、课题设计目的(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. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。
在进行稀疏矩阵的转置运算时,只需要将矩阵的非零元素的行号和列号对换即可。
五、实验结果与分析我们在实现稀疏矩阵运算器后,对其进行了测试。
通过测试,我们发现稀疏矩阵运算器能够正确地进行稀疏矩阵的加法、乘法和。
稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现稀疏矩阵是指在一个大型矩阵中,绝大部分元素为零,只有少部分元素非零。
在实际应用中,由于很多矩阵中只有极少数的元素具有实际意义,这种情况是很常见的。
为了节省存储空间和提高计算效率,我们可以使用三元组表示稀疏矩阵,并进行相应的实现。
三元组表示稀疏矩阵的基本思想是将矩阵中的非零元素的行、列及其值存储起来,以此表示整个稀疏矩阵。
它可以使用三个数组来实现:一个数组用于存储非零元素的值,一个数组用于存储非零元素的行号,另一个数组用于存储非零元素的列号。
这样,对于一个m×n的稀疏矩阵,这三个数组的长度就是非零元素的个数。
三元组表示的稀疏矩阵在实际应用中具有以下特点:1.节省存储空间:由于只存储非零元素,因此可以大大减少存储空间的使用,尤其在元素总数远大于非零元素数目的情况下。
2.提高计算效率:对于稀疏矩阵,很多计算操作可以直接跳过零元素,只对非零元素进行计算,从而提高计算效率。
3.易于读取和修改:三元组表示使得读取和修改稀疏矩阵变得相对容易,因为只需要根据存储的三元组信息进行操作即可。
在实现三元组表示稀疏矩阵时,首先需要确定数据结构的形式。
一种常见的方式是使用类来表示三元组,其中类的成员变量分别对应非零元素的值、行号和列号。
这样每个实例对象代表一个非零元素。
另外,还可以使用数组来表示存储该矩阵所有的非零元素。
接下来是具体的实现步骤:1.初始化一个空的三元组数组,长度为非零元素的个数。
2.遍历整个稀疏矩阵,当遇到一个非零元素时,将其值、行号和列号分别存储到三元组数组中的对应位置。
3.结束遍历后,三元组数组中的每一个实例对象就代表一个非零元素。
4.根据实际应用的需要,可以在三元组数组中实现相应的操作,如查找指定位置的元素、修改元素的值等。
对于稀疏矩阵的三元组表示的实现,有以下几个注意点:1.非零元素的顺序:算法的效率与非零元素的顺序有关,可以对非零元素按行或列的顺序进行排序,这样可以提高一些查找操作的效率。
矩阵求和的报告

实验题目稀疏矩阵求和运算实验报告一、实验目的与要求稀疏矩阵求和,要求稀疏矩阵采用三元组压缩存储结构。
要求:1.掌握稀疏矩阵的三元组存储表示方式;2.根据矩阵的求和规则实现A、B矩阵的求和运算,并将运算结果存储在C矩阵中。
3.要求A、B矩阵由键盘输入,所有矩阵均采用三元组存储。
二、实验方案算法思想:稀疏矩阵采用三元组压缩存储结构,首先,如果两矩阵的的元素行相等,同时列也相等就值相加,若列不相等,就比较列号的大小,按正序插入;如果两矩阵的的元素行不相等,就比较行号的大小,按正序插入。
#define MAX 100typedef struct{ int row,col;int val;}TriNode;typedef struct{ TriNode data[MAX];int m,n,t;}TriTable;void CreateTri(TriTable *p){ int i;printf("please input the number of row,col and not zero: ");scanf("%d,%d,%d",&p->m,&p->n,&p->t);printf("an hang you xian shu ru the number of row,col and val: \n");for (i=1;i<=p->t;i++)scanf("%d,%d,%d",&p->data[i].row,&p->data[i].col,&p->data[i].val);}void OutputTri(TriTable *p){ int i;printf("\n");printf("gai ju zhen yuan shu wei:\n");for (i=1;i<=p->t;i++)printf("%d ,%d ,%d \n",p->data[i].row,p->data[i].col,p->data[i].val);}void AddTri(TriTable *pa,TriTable *pb,TriTable *pc){ int i,j,k;i=j=k=1;while( pa->t-i>=0 && pb->t-j>=0)if(pa->data[i].row==pb->data[j].row) /*行相等*/{ if(pa->data[i].col==pb->data[j].col) /*列相等*/{ if ((pa->data[i].val+pb->data[j].val)!=0){ pc->data[k].row=pa->data[i].row;pc->data[k].col=pa->data[i].col;pc->data[k].val=pa->data[i].val+pb->data[j].val; /*求和*/k++;i++;j++;}else {i++;j++;}}else{ if (pa->data[i].col<pb->data[j].col) /*列不等*/{ pc->data[k].row=pa->data[i].row;pc->data[k].col=pa->data[i].col;pc->data[k].val=pa->data[i].val;k++;i++;}else{ pc->data[k].row=pb->data[j].row;pc->data[k].col=pb->data[j].col;pc->data[k].val=pb->data[j].val;k++;j++;} } }else{ if(pa->data[i].row<pb->data[j].row) /*行不等*/{ pc->data[k].row=pa->data[i].row;pc->data[k].col=pa->data[i].col;pc->data[k].val=pa->data[i].val;k++;i++;}else{ pc->data[k].row=pb->data[j].row;pc->data[k].col=pb->data[j].col;pc->data[k].val=pb->data[j].val;k++;j++;} }if (pa->t-i>=0)for (;i<=pa->t;i++){ pc->data[k].row=pa->data[i].row;pc->data[k].col=pa->data[i].col;pc->data[k].val=pa->data[i].val;k++;}if (pb->t-j>=0)for (;j<=pb->t;j++){ pc->data[k].row=pb->data[j].row;pc->data[k].col=pb->data[j].col;pc->data[k].val=pb->data[j].val;k++;}pc->m=pa->m;pc->n=pa->n;pc->t=k-1;}main(){ TriTable *ma,*mb,*mc;ma=(TriTable*)malloc(sizeof(TriTable));mb=(TriTable*)malloc(sizeof(TriTable));mc=(TriTable*)malloc(sizeof(TriTable));CreateTri(ma);OutputTri(ma);CreateTri(mb);OutputTri(mb);AddTri(ma,mb,mc);OutputTri(mc);getch();}三、实验结果和数据处理数组为:A .|2 0| B.|0 3| A+B.|2 3||0 4| |1 3| |1 7|四、结论本次实验过程中主要遇到的问题有以下几点:1.错误不是一个允许的类型在函数中,是因为定义类型时不符合要求。
稀疏矩阵课程设计实验报告

数据结构课程设计学院:信息科学与工程学院专业:计算机科学与技术班级:计算机1108学号:学生姓名:指导教师:2013 年 3 月 10 日稀疏矩阵一、实验内容基本要求:1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加、想减、相乘的运算。
2.稀疏矩阵的输入形式采用三元组表表示,而运算结果则以通常的阵列形式输出选作内容:1.按书中的描述方法,以十字链表表示稀疏矩阵2.增添矩阵求逆的运算,包括不可求逆的情况。
在求逆之前,先将稀疏矩阵的内容表示改为十字链表…二、数据结构设计三元组结构体定义如下:#include <stdio.h>#include <stdlib.h>#define MAX 100typedef struct{int i,j;int e;}Triple;struct juzhen{Triple data[MAX+1];int first[MAX+1];int mv,nv,tv;};十字链表结构定义如下#include<stdio.h>#include<stdlib.h>#include<conio.h>typedef int ElemType;typedef struct CLNode{int row ;int col;ElemType fenzi;ElemType fenmu;CLNode * right;CLNode * down;}CLNode;typedef struct{CLNode ** rhead;CLNode ** chead;int ru;int lu;int tu;}CrossList;三、算法设计1.三元组表构建稀疏矩阵的定义如下:ADT Matrix{数据对象:D={a ij|i=1,2,…,m; j=1,2,…,n;a ij∈ElemSet, 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+1,j﹥| 1≤i≤m-1, 1≤j≤n}基本操作:ChuangJian (XiShu &M)操作结果:创建稀疏矩阵矩阵TMShuChu(XiShu Q)操作结果:通常形式输出稀疏矩阵AddMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的加法运算:void JianMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的减法运算void ChengMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的乘法运算}ADT Matrix;2 十字链表创建稀疏矩阵的定义如下:ADT SparseMatrix{数据对象 D={a ij|i=1,2,3……m,j=1,2,3……n;a ij属于ElemSet,m和n分别是稀疏矩阵的行数和列数}数据关系 R={ Row, Col }Row={<a ij,a ij+1>|1<=i<=m,1<=j<=n-1}Col={<a ij,a i+1j>|1<=i<=m-1,1<=j<=n}基本操作:void Input( CrossList &D )操作结果:十字链表创建稀疏矩阵int Determinant( const CrossList &D ,int row , int line )操作结果:求稀疏矩阵行列式的值void Reduction( int &fenzi, int &fenmu )操作结果:分子分母约分CrossList *InverseMatrix( const CrossList &D )操作结果:求稀疏矩阵的逆矩阵void Output( const CrossList *E )操作结果:十字邻接矩阵的输出}ADT SparseMatrix3.1 功能模块图本功能分为四个模块3.2 算法思路3.2.1实现方法列出系统中的所有函数并说明函数的功能void main() //三元组表法和十字链表的主函数int ChuangJian(XiShu *M) //三元组表法创建稀疏矩阵void ShuChu(XiShu Q) //三元组表法输出稀疏矩阵void AddMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相加功能void JianMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相减功能void ChengMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相乘功能int Determinant(CrossList &D ,int row ,int line )//行列式求值void Reduction( int &fenzi, int &fenmu ) //分子分母约分void Input( CrossList &D ) //十字链表输入函数CrossList *InverseMatrix(CrossList &D)//求稀疏矩阵的逆矩阵void Output( const CrossList *E ) //十字链表输出函数3.2.2 设计思想稀疏矩阵加法运算思路:首先判断两个矩阵行数列数是否相等,比较两个矩阵中不为0的元素的行数i 及列数j,将i与j都相等的前后两个元素值e相加,保持i,j不变储存在新的三元组中,不等的则分别储存在此新三元组中稀疏矩阵减法运算思路:将后一个矩阵的每一个非零元都乘以-1,再调用加法运算的函数稀疏矩阵乘法运算思路:逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加稀疏矩阵求逆运算的思路:矩阵的逆等于矩阵的伴随矩阵除以矩阵行列式的值(1)定义全局变量#define MAX 100#define TRUE 1#define FAULT 0typedef int ElemType;(2)主函数模块说明主函数主要结构void main( ){ 初始化;Switch(){Case :接受命令;选择处理命令}不满足退出}void main( ){初始化;接受命令;选择处理命令}(3)其他模块说明(用文字描述,不要代码)int CreateSMatrix(TSMatrix *M){初始化;输入行数、列数、非零元个数for(){for()按行为主序输入每一个非零元赋值}返回结果}void PrintSMatrix(TSMatrix Q){两层for循环输出每一个非零元}void AddRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){判断行数、列数是否对应相等,若均相等则相加并赋值否则依次判断行数、列数的大小并再次判断将值放在另一个数组里}Void JianRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){两层for循环将第二个矩阵的每一个非零元变为他的负数再调用相加函数}void MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){初始化判断第一个矩阵的行数时候等于第二个矩阵的列数然后逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加}四、测试数据及程序运行情况三元组表实现加法运算三元组表实现乘法运算十字链表实现求逆运算五、实验过程中出现的问题及解决方案1)问题:运行过程中发现加法减法能正常运行,而乘法却在计算时出现问题。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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;
}
四实验结果。