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

合集下载

三元组实现稀疏矩阵的相乘

三元组实现稀疏矩阵的相乘学院：班级：姓名：学号：一、实验题目：建立三元组，并以三元组为储存结构储存两个稀疏矩阵，并实现他们的相乘，输出结果。

二、需求分析：定义一个一维数组，它用来以行序为主序依次存放所有非零元构成的三元组，并定义变量分别记录矩阵的行数、列数非零元个数以及数组大小。

按照这种方式定义三元组的数据实现两个稀疏矩阵的乘法操作。

三、概要设计：建立一个三元组的结点：struct Node{int Row,Col; // 三元组Á的行列号?int Value; // 元素的值};用以储存稀疏矩阵，建立A和B两个稀疏矩阵用三元组表来储存非零元的行数、列数、值，再相乘输出结果。

四、详细设计：建立三元组：struct Node{int Row,Col; // 三元组Á的行列号?int Value; // 元素的值};建立三元组表：struct SparMatrix{int Rows,Cols; // 矩的行列数int Terms; // 矩阵的非零元个数struct Node arrayData[MAX_SIZE]; // 存放矩阵非零元素的三元组数组void PrintMatrix(); // 输出矩阵int GetElement(int m ,int n); // 获得矩阵对应的元素void PrintInit(); // 矩阵的输初始化void AddElement(int m,int n, int Value); // 增加非零元素};矩阵相乘：SparMatrix* MatrixMulti(SparMatrix* pM1,SparMatrix* pM2);void main(){SparMatrix matrix1;cout<<"The 1st matrix:"<<endl;matrix1.PrintInit();SparMatrix matrix2;cout<<"The 2nd matrix:"<<endl;matrix2.PrintInit();cout<<"Multiplication:"<<endl;matrix1.PrintMatrix();cout<<"*"<<endl;matrix2.PrintMatrix();cout<<"="<<endl;SparMatrix* pMatrixPro;pMatrixPro = MatrixMulti(&matrix1,&matrix2);if (pMatrixPro == NULL){cout<<"Error!"<<endl;}else{pMatrixPro->PrintMatrix();}if (pMatrixPro != NULL){delete pMatrixPro;pMatrixPro = NULL;}}五、程序使用说明：首先会看到“Please input the row and col num, using space to separate them:”的字样，这时候请输入你所要建立稀疏矩阵行数列数。

稀疏矩阵运算器实验报告

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的矩阵。

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

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

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

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

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

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

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

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

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

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

4.编写实验报告。

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

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

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

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

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

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

实验5稀疏矩阵三元组表的操作1

实验五稀疏矩阵三元组表的操作科目：数据结构实验和课程设计班级： 10信管姓名：徐杨学号：2010110450 实验目的：会定义稀疏矩阵的三元组表。

熟悉C语言程序的基本结构，掌握程序中的用户头文件、文件之间的相互关系及各自的作用。

熟悉对稀疏矩阵的三元组表的一些基本操作和具体的函数定义。

熟悉C语言操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。

实验要求：认真阅读和掌握本实验内容所给的全部程序。

保存和输出程序运行结果，并结合程序进行分析。

按照你对稀疏矩阵的三元组表操作的需要，编写程序代码然后运行，给出运行结果。

实验设备：每人一台安装VC6.0编写软件的计算机，公用打印机。

注意事项：要在硬盘上建立好自己的工作目录，专门用来存储自己所做的实验程序及相关数据，以后每次做实验最好仍采用这个目录。

认真编写算法及运行结果，针对本实验的具体算法，认真写出算法分析。

一、实验步骤：#include<iostream.h>//稀疏矩阵三元组表的操作#define maxsize 64#define M#define Ntypedef int elemtype;struct node{int r,c;elemtype d;};struct ts{int rows,cols,nums;node data[maxsize];};void create(ts &a);//稀疏矩阵三元组表的建立void disp(ts a);//显示稀疏矩阵三元组表的内容void trants(ts a,ts &at); //求稀疏矩阵的转置void add(ts a,ts b,ts &c);//求两稀疏矩阵的和void main(){ts a;create(a); //稀疏矩阵三元组表的建立disp(a); //显示稀疏矩阵三元组表的内容ts at;trants(a,at); //求稀疏矩阵的转置disp(at); //显示转置矩阵的内容ts b;create(b);disp(b); //稀疏矩阵三元组表的建立ts c;add(a,b,c); //求两稀疏矩阵的和disp(c); //显示两稀疏矩阵和的内容}void create(ts &a) //稀疏矩阵三元组表的建立{ cout<<"建立稀疏矩阵三元组表:"<<endl;cout<<"稀疏矩阵的行数为:";cin>>a.rows;cout<<"稀疏矩阵列的数为:";cin>>a.cols;cout<<"稀疏矩阵中非零的元素个数为:";cin>>a.nums;cout<<"稀疏矩阵的三元组表为:"<<endl;for(int i=0;i<a.nums;i++){cin>>a.data[i].r>>a.data[i].c>>a.data[i].d;}}void disp(ts a) //显示稀疏矩阵三元组表的内容{ int i;cout<<"显示稀疏矩阵三元组表:"<<endl;if(a.nums<=0) return;cout<<"行数为:"<<a.rows<<" "<<"列数为:"<<a.cols<<" "<<"元素个数为:"<<" "<<a.nums<<endl;cout<<"------------------------"<<endl;for(i=0;i<a.nums;i++)cout<<a.data[i].r<<" "<<a.data[i].c <<" "<<a.data[i].d <<endl;}void trants(ts a,ts &at)//求稀疏矩阵的转置{ int p,q=0,v;at.rows=a.cols;at.cols=a.rows;at.nums=a.nums;if(a.nums!=0){ for(v=0;v<a.cols;v++)for(p=0;p<a.nums;p++)if(a.data[p].c==v){at.data[q].r=a.data[p].c;at.data[q].c=a.data[p].r;at.data[q].d=a.data[p].d;q++;}}cout<<"转置后的稀疏矩阵:"<<endl;}void add(ts a,ts b,ts &c) //求两稀疏矩阵的和{int i=0,j=0,k=0;elemtype v;if (a.rows!=b.rows||a.cols!=b.cols)c.rows=a.rows;c.cols=a.cols;while (i<a.nums&&j<b.nums){if(a.data[i].r==b.data[j].r){if(c.data[i].c<b.data[j].c){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if(a.data[i].c>b.data[j].c){c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else{v=a.data[i].d+b.data[j].d;if(v!=0){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if(a.data[i].r<b.data[j].r){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else{c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}cout<<"两个稀疏矩阵求和后元素的个数为:"<<c.nums<<endl; }二、运行结果：三、算法分析：。

4.1稀疏矩阵运算器

稀疏矩阵运算器一．实验目的使读者能深入研究数组的存储表示和实现技术二．实验内容【问题描述】稀疏矩阵是指那些多数元素为零的矩阵，利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。

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

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

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

【实现提示】1、首先应先输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求做的运算是否相匹配，可设矩阵的行数和列数不超过20；2、程序可以对三元组的输入顺序加以限制，例如，按行优先。

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

三．实验步骤（可选）#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;#define MAXSIZE 100#define MAXROW 100#define OK 1#define ERROR -1typedef struct{int row; //行数int col; //列数int v; //非零元素值}triplenode;typedef struct{triplenode data[MAXSIZE+1]; //非零元三元组int rowtab[MAXROW+1];//各行第一个非零元的位置表int mu,nu,tu; //矩阵的行数、列数和非零元个数}rtripletable;void creat(rtripletable &A){ //创建稀疏矩阵int k=1,sum=1,loop,p,t;int num[MAXROW+1];cout<<"请输入矩阵的行数和列数:"<<endl;cout<<"行数:";cin>>A.mu;cout<<"列数:";cin>>A.nu;cout<<"非零元素个数:";cin>>A.tu;cout<<"请输入该矩阵的非零元:格式行+列+值.(ps:以输入全零为结束标记!）"<<endl;for(loop=1;loop<=A.tu;loop++){//输入三元组的行数，列数和非零元素值cin>>A.data[loop].row;cin>>A.data[loop].col;cin>>A.data[loop].v;}for(p=1;p<=A.mu;p++) num[p]=0;//A三元组每一列的非零元素个数for(t=1;t<=A.tu;t++) ++num[A.data[t].row];//求A中每一列含非零元个数A.rowtab[1]=1;//求第p列中第一个非零元在A.data中的序号for(t=2;t<=A.mu;t++) A.rowtab[t]=A.rowtab[t-1]+num[t-1];return;}void print(rtripletable A){ //输出稀疏矩阵int result[MAXROW+1][MAXROW+1];//定义一个二维数组int i,j;for(i=1;i<=A.mu;i++)for(j=1;j<=A.nu;j++)result[i][j]=0; //初始化为0for(i=1;i<=A.tu;i++)result[A.data[i].row][A.data[i].col]=A.data[i].v;for(i=1;i<=A.mu;i++){//输出所做运算的结果for(j=1;j<=A.nu;j++)cout<<result[i][j]<<"\t";cout<<endl;}}int addsmatrix(rtripletable M, rtripletable N){//矩阵相加if(M.mu!=N.mu) //行数相等才能相加cout<<"ERROR";rtripletable Q;Q.mu=M.mu;Q.nu=N.nu;int p,q,k;p=1;q=1;k=1;while(p<=M.tu&&q<=N.tu){//两个稀疏矩阵存在if(M.data[p].row==N.data[q].row){//两个稀疏矩阵的行数相等if(M.data[p].col==N.data[q].col){//两个稀疏矩阵的列数相等if(M.data[p].v+N.data[q].v!=0){//两个稀疏矩阵相加的结果不为0Q.data[k].row=M.data[p].row;Q.data[k].col=M.data[p].col;Q.data[k].v=M.data[p].v+N.data[q].v;++k;}++q;++p;}else if(M.data[p].col<N.data[q].col){//第一个稀疏矩阵列数小于第二个稀疏矩阵列数Q.data[k]=M.data[p];//把M中的所有信息都赋给Q++p;++k;}else{ //第一个稀疏矩阵列数大于第二个稀疏矩阵的列数Q.data[k]=N.data[q];++q;++k;}}else if(M.data[p].row<N.data[q].row){ //第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=M.data[p];++p;++k;}else{ //第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=N.data[q];++q;++k;}}while(p<=M.tu){ //只有M并且符合条件Q.data[k]=M.data[p];++p;++k;}while(q<=N.tu){ //只有N并且符合条件Q.data[k]=N.data[q];++q;++k;}Q.tu=k-1;cout<<"矩阵相加结果是:"<<endl;print(Q); //调用print()return OK;}int subsmatrix(rtripletable M, rtripletable N){ //稀疏矩阵相减if(M.mu!=N.mu) //行数相等才能相加cout<<"出错";rtripletable Q;Q.mu=M.mu;Q.nu=N.nu;int p,q,k;p=1;q=1;k=1;while(p<=M.tu&&q<=N.tu){ //两个稀疏矩阵存在if(M.data[p].row==N.data[q].row){ //两个稀疏矩阵的行数相等if(M.data[p].col==N.data[q].col){ //两个稀疏矩阵的列数相等if(M.data[p].v-N.data[q].v!=0){ //两个稀疏矩阵相减的结果不为0Q.data[k].row=M.data[p].row;Q.data[k].col=M.data[p].col;Q.data[k].v=M.data[p].v-N.data[q].v;++k;}++q;++p;}if(M.data[p].col<N.data[q].col){ //第一个稀疏矩阵列数小于第二个稀疏矩阵的列数Q.data[k]=M.data[p];++p;++k;}if(M.data[p].col>N.data[q].col){ //第一个稀疏矩阵列数大于第二个稀疏矩阵的列Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}}if(M.data[p].row<N.data[q].row){//第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=M.data[p];++p;++k;}if(M.data[p].row>N.data[q].row){//第一个稀疏矩阵行列数大于第二个稀疏矩阵行数Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}}while(p<=M.tu){//只有M并且符合条件Q.data[k]=M.data[p];++p;++k;}while(q<=N.tu){//只有N并且符合条件Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}Q.tu=k-1;cout<<"矩阵相减结果为:"<<endl;print(Q); //调用print()return OK;}void multsmatrix(rtripletable M, rtripletable N, rtripletable &Q){//稀疏矩阵相乘int arow,brow;int p,q,tp,t;int ccol;int ctemp[MAXROW+1]; //定义累加器if(M.nu!=N.mu)return;Q.mu=M.mu;Q.nu=N.nu;Q.tu=0; //Q初始化if(M.tu*N.tu!=0){ //Q是非零矩阵for(arow=1;arow<=M.mu;arow++){//处理M的每一行for(p=1;p<=Q.nu;p++) //处理M的每一列ctemp[p]=0; //当前行各元素累加器清零Q.rowtab[arow]=Q.tu+1;if(arow<M.mu) tp=M.rowtab[arow+1];else tp=M.tu+1;for(p=M.rowtab[arow];p<tp;++p){//对当前行中每一个非零元brow=M.data[p].col; //找到对应元N中的行号if(brow<N.nu) t=N.rowtab[brow+1];else t=N.tu+1;for(q=N.rowtab[brow];q<t;++q){ccol=N.data[q].col; //乘积元素在Q中列数ctemp[ccol]+=M.data[p].v*N.data[q].v;}} //求得Q中第crow(=arow)行的非零元for(ccol=1;ccol<=Q.nu;ccol++){//压缩存储该行非零元if(ctemp[ccol]){if(++Q.tu>MAXSIZE)return ;Q.data[Q.tu].row=arow; //行数Q.data[Q.tu].col=ccol; //列数Q.data[Q.tu].v=ctemp[ccol];}}}}//累加非零元素值cout<<"乘法结果为:"<<endl;print(Q);} //调用print()void main(){char choice;rtripletable A,B,Q;cout<<"**********************************"<<endl;cout<<"*****欢迎使用稀疏矩阵运算器******"<<endl;cout<<"**********************************"<<endl;cout<<"A、输入矩阵1"<<"\t";cout<<"B、输入矩阵2"<<"\t";cout<<"C、矩阵相加"<<endl;cout<<"D、矩阵相减"<<"\t";cout<<"E、矩阵相乘"<<"\t";cout<<"F、退出本系统"<<endl;cout<<"请选择所需要的操作功能(A，B，C，D，E，F):";do{cin>>choice;switch(choice){case'A':creat(A);break;case'B':creat(B);break;case'C':addsmatrix(A,B);break;case'D':subsmatrix(A,B);break;case'E':multsmatrix(A,B,Q);break;case'F':exit(0);}cout<<"请选择所需要的操作功能(A，B，C，D，E，F):";}while(1);} 四．实验的结果及分析。

稀疏矩阵编程实验报告

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

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

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

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

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

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

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

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

软件平台：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.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义，掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素（三元组分别储存非零元素的行下标，列下标和元素值）。

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

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

第三步：重复第二步，知道二维数组中所有的元素已经取出。

3.稀疏矩阵倒置算法：第一步：判断进行倒置的矩阵是否为空矩阵，如果是，则直接返回错误信息。

第二步：计算要倒置的矩阵每列非零元素的数量，存入到num数组（其中num[i] 代表矩阵中第i列非零元素的个数）。

以及倒置后矩阵每行首非零元的位置，存入cpot 数组中（其中cpot表示倒置后矩阵每行非零元的位置，对应表示原矩阵每列中第一个非零元的位置）。

第三步：确定倒置后矩阵的行数和列数。

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

cpot[j] 变量加一。

第五步：重复第四步，直到三元组表中所有的元素都完成倒置。

第六步：把完成倒置运算的三元组表输出。

4.稀疏矩阵加法算法：第一步：检查相加两个矩阵的行数和列数是否相同，如果相同，则进入第二步，否则输出错误信息。

第二步：定义变量i和j，用于控制三元组表的遍历。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

基于三元组表的存储结构实现稀疏矩阵的应用课程设计,实验报告

基于三元组表的存储结构实现稀疏矩阵的应用课程设计，实验报告数据结构课程设计设计题目:基于三元组表的存储结构实现稀疏矩阵的应用学生姓名: 专业班级: 指导教师: 完成时间:信息工程学院信科系课程设计成绩评定表(本科)课题名称基于三元组表的存储结构实现稀疏矩阵的基本操作院系年级专业学号姓名成绩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)掌握稀疏矩阵三元组表的存储，创建，显示，转置等方法。

稀疏矩阵三元组实验报告

一、设计人员相关信息
1.设计者姓名、学号和班号：12地信李晓婧12012242983
2.设计日期：2014.
3.上机环境：VC++6.0
二、程序设计相关信息
1.实验题目：实验题6.4 假设n*n的稀疏矩阵A采用三元组表示，设计一个程序实现
如下功能：（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组。

| 1 0 3 1 |
| 0 1 0 0 |
| 0 0 1 0 |
| 0 0 1 1 |
2.实验项目组成：
（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组
3.实验项目的程序结构（程序中的函数调用关系图）：
4.实验项目包含的各个文件中的函数的功能描述：
CreatMat：对一个二维稀疏矩阵创建其三元组表示，以行序方式扫描二维稀疏矩阵A，将其非零的元素插入到三元组t中。

DispMat：输出三元组。

从头到尾扫描三元组t，依次输出元素值。

TranMat：矩阵转置。

对一个m*n的矩阵A m*n，其转置矩阵是一个n*m的矩阵，设为
B n*m，满足a i，j=b i，j，其中0≤i≤m-1，0≤j≤n-1。

5.算法描述或流程图：
6.实验数据和实验结果：
7.出现的问题及解决方案
主函数缺少一次输出，稀疏矩阵没有显示。

解决方案：主函数加一个输出稀疏矩阵disp（A）。

三、程序盘
提交的程序盘应包含全部的源程序清单和可执行文件。

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

课程设计课程：数据结构题目：稀疏矩阵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. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高，尤其在稀疏程度较高的矩阵上。

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

稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现
稀疏矩阵是指其中大部分元素为0的矩阵。

为了节省存储空间和提高计算效率，常常使用三元组表示法来表示稀疏矩阵。

稀疏矩阵的三元组表示由三个数组组成，分别存储非零元素的行号、列号和值。

具体实现如下：
1. 定义一个结构体来表示稀疏矩阵的三元组，包括行号、列号和值。

```C++
struct SparseMatrix {
int row;
int col;
int value;
};
```
2. 创建一个数组，用来存储稀疏矩阵中的非零元素的三元组。

```C++
SparseMatrix sparseMatrix[maxSize]; // maxSize为稀疏矩阵中非零元素的个数
```
3. 初始化稀疏矩阵的三元组表示。

4. 对于每个非零元素，将其行号、列号和值存入稀疏矩阵的三元组数组中。

```C++
sparseMatrix[i].row = ...; // 非零元素的行号
sparseMatrix[i].col = ...; // 非零元素的列号
sparseMatrix[i].value = ...; // 非零元素的值
```
稀疏矩阵的三元组表示将只有非零元素的信息存储，从而节省了存储空间。

同时，通过遍历只包含非零元素的数组，可以高效地进行各种矩阵运算。

数据结构实验报告_9

本科生实验报告（二）姓名:学院:专业:班级:实验课程名称: 数据结构实验日期: 2013年 5月 25 日指导教师及职称:实验成绩:开课时间：2012～2013 学年第二学期k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}}运行结果：6.2：如果矩阵A中存在这样的一个元素A[i][j]满足条件：A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称为该矩阵的一个马鞍点。

设计一个程序exp6-2.cpp 计算出m*n的矩阵A的所有马鞍点。

主程序如下：6.3：已知A和B为两个n*n阶的对称矩阵，输入时，对称矩阵只输入下三角形元素，存入一维数组，如图6.5所示（对称矩阵M存储在一维数组A中），设计一个程序exp6-3.cpp 实习如下功能：（1）求对称矩阵A和B的和。

（2）求对称矩阵A和B的乘积。

A:图6.5 对称矩阵的存储转换形式主程序如下：#include <stdio.h>#define N 4#define M 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[][N]){int i,j;for (i=0;i<N;i++)printf("a+b:\n");disp2(c1);printf("a×b:\n");disp2(c2);printf("\n");}运行结果：6.4：：假设n*n的稀疏矩阵A采用三元组表示，设计一个程序exp6-4.cpp实现如下功能：（1）生成如下两个稀疏矩阵矩阵的三元组a和b:（2）输出a转置矩阵的三元组；（3）输出a+b的三元组；（4）输出a*b的三元组。

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

实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（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到TAddSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的和Q=M+NSubSMatrix(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 4typedef 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元素行列变换一下赋值到新的矩阵中即可。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

矩阵求和的报告

实验题目稀疏矩阵求和运算实验报告一、实验目的与要求稀疏矩阵求和，要求稀疏矩阵采用三元组压缩存储结构。

要求：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）问题：运行过程中发现加法减法能正常运行，而乘法却在计算时出现问题。

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

三元组实现稀疏矩阵的相乘

稀疏矩阵运算器实验报告

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

实验5稀疏矩阵三元组表的操作1

4.1稀疏矩阵运算器

稀疏矩阵编程实验报告

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

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

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

基于三元组表的存储结构实现稀疏矩阵的应用课程设计,实验报告

稀疏矩阵三元组实验报告

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

稀疏矩阵实验报告

稀疏矩阵的三元组表示和实现

数据结构实验报告_9

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

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

矩阵求和的报告

稀疏矩阵课程设计实验报告

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