(完整word版)实现稀疏矩阵(采用三元组表示)的基本运算实验报告
数据结构-稀疏矩阵实验报告
实验报告
课程 学号 数据结构 姓名 实验名称 实验四 稀疏矩阵 实验日 期： 2012/11/12
实验四 实验目的：稀疏矩阵1.熟悉数组在计算机内存中存储的实现机制； 2.熟练并掌握数组的基本运算； 3.熟悉并掌握特殊矩阵的压缩存储方法及压缩存储下的矩阵的运算； 3.熟悉稀疏矩阵的“三元组表”和“十字链表”存储结构。
if(i<=j) { for(k=1;k<=n;k++) { if(i<=k) p=k*(k-1)/2+i-1; else p=n*(n+1)/2; if(j>=k) q=j*(j-1)/2+k-1; else q=n*(n+1)/2; sum=sum+a[p]*b[q]; } c[j*(j-1)/2+i-1]=sum; sum=0; } else c[n*(n+1)/2]=0; } } void print(int a[], int n) { int i,j; for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { if(i<=j) printf("%5d", a[j*(j-1)/2+i-1]); else printf("%5d", a[n*(n+1)/2]); } printf("\n"); } } void main() { int u[]={1,2,4,3,5,6,0}; int v[]={10,20,40,30,50,60,0}; int c[7], n=3; add(u,v,c,n); printf("C=A+B=\n"); print(c,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;
数据结构实验报告三稀疏矩阵的运算
数据结构实验报告三稀疏矩阵的运算实验课程名称数据结构课程设计专业班级学⽣姓名学号指导教师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.实现稀疏矩阵加法、乘法的算法，并进行性能测试和分析。
实验原理：稀疏矩阵是指矩阵中绝大多数元素为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. 通过编程实现稀疏矩阵的基本操作，验证了算法的正确性。
用三元组表示稀疏矩阵的乘法
该结点除了（ row ， col ， value ）以外，还要有以下两个链域：
right： down： 用于链接同一列中的下一个非零元素。
row Down
col
Value right
第十二讲
1 1 3
1 4 5
2 2 －1
3 1 3
图5.23 十字链表的结构
第十二讲
十字链表的结构类型说明如下：
typedef struct OLNode
第十二讲
用三元组表实现稀疏矩阵的乘法运算
第十二讲
两个矩阵相乘也是矩阵的一种常用的运算。设矩阵 M 是
m1×n1 矩阵， N 是 m2×n2 矩阵；若可以相乘，则必须满足矩
阵 M 的列数 n1 与矩阵 N 的行数 m2 相等，才能得到结果矩阵 Q=M×N（一个m1×n2的矩阵）。
数学中矩阵Q中的元素的计算方法如下：
矩阵不仅节约了空间，而且使得矩阵某些运算的运算时间比经
典算法还少。但是在进行矩阵加法、减法和乘法等运算时，有 时矩阵中的非零元素的位置和个数会发生很大的变化。如
A=A+B， 将矩阵B加到矩阵A上，此时若还用三元组表表示法，
势必会为了保持三元组表“以行序为主序”而大量移动元素。
第十二讲
在十字链表中，矩阵的每一个非零元素用一个结点表示，
0 1 N 2 0
2 0 4 0
0 Q 1 0
6 0 4
图5.17 Q=M×N
第十二讲
图5.18 矩阵M、N、Q的三元组表
第十二讲
经典算法中，不论 M ［ i ］［ k ］、 N ［ k ］［ j ］是否为零，
for(k=1; k<=n1; k++)
数据结构实验报告稀疏矩阵运算
教学单位计算机科学与技术学生学号************数据结构课程设计报告书题目稀疏矩阵运算器学生姓名秦豹专业名称软件工程指导教师李志敏实验目的：深入研究数组的存储表示和实现技术，熟悉广义表存储结构的特性。
需要分析：稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
要求以带“行逻辑链接信息”的三元组顺序表存储稀疏矩阵，实现两矩阵的相加、相减、相乘等运算。
输入以三元组表示，输出以通常的阵列形式列出。
软件平台：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，用于控制三元组表的遍历。
稀疏矩阵实验报告（包括问题描述，源代码，实验结果等）
数据结构课程设计实习报告题目：班级：学号：姓名：实习报告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)了解稀疏矩阵的相关应用。
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. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高，尤其在稀疏程度较高的矩阵上。
- 稀疏矩阵运算的缺点是存储空间较大，且运算过程中需要频繁进行数据交换。
实现稀疏矩阵采用三元组表示的基本运算实验报告
实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（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元素行列变换一下赋值到新的矩阵中即可。
矩阵求和的报告
实验题目稀疏矩阵求和运算实验报告一、实验目的与要求稀疏矩阵求和，要求稀疏矩阵采用三元组压缩存储结构。
要求：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）问题：运行过程中发现加法减法能正常运行，而乘法却在计算时出现问题。
稀疏矩阵运算器
} 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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（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)操作结果：创建稀疏矩阵MPrintSMatrix(M)初始条件：稀疏矩阵M已经存在操作结果：打印矩阵MDestroySMatrix(&M)初始条件：稀疏矩阵M已经存在操作结果：销毁矩阵MCopySMatrix(M, &T)初始条件：稀疏矩阵M已经存在操作结果：复制矩阵M到TAddSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的和Q=M+NSubSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的差Q=M-NTransposeSMatrix(M, & T)初始条件：稀疏矩阵M已经存在操作结果：求矩阵M的转置TMultSMatrix(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.nums].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元素行列变换一下赋值到新的矩阵中即可。
2.矩阵加法：用各种 if 判断，区分出矩阵进行加法时的可能情况，分情况处理即可。
3.矩阵乘法：通过 getvalue（c ， i， j）函数查找矩阵c 中i 行j列，所储存的元素的值。
然后便是模拟矩阵乘法的过程进行求解。
3.5解题过程：实验源代码如下：3.5.1顺序表的各种运算#include <stdio.h>#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; //三元组顺序表定义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.nums].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 );}void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; //q为tb.data的下标tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) //tb.data[q]中的记录以c域的次序排列for (p=0;p<t.nums;p++) //p为t.data的下标if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return false; //行数或列数不等时不能进行相加运算c.rows=a.rows;c.cols=a.cols; //c的行列数与a的相同while (i<a.nums && j<b.nums) //处理a和b中的每个元素{if (a.data[i].r==b.data[j].r) //行号相等时{if(a.data[i].c<b.data[j].c) //a元素的列号小于b元素的列号{c.data[k].r=a.data[i].r;//将a元素添加到c中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)//a元素的列号大于b 元素的列号{c.data[k].r=b.data[j].r; //将b元素添加到c中 c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else //a元素的列号等于b元素的列号{v=a.data[i].d+b.data[j].d;if (v!=0) //只将不为0的结果添加到c中{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) //a元素的行号小于b元素的行号{c.data[k].r=a.data[i].r; //将a元素添加到c中c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else //a元素的行号大于b元素的行号{c.data[k].r=b.data[j].r; //将b元素添加到c中c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return true;}int getvalue(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j)) k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}bool MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) //a的列数不等于b的行数时不能进行相乘运算return false;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+getvalue(a,i,k)*getvalue(b,k,j);if (s!=0) //产生一个三元组元素{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=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;}四实验结果。