数据结构实验报告稀疏矩阵运算
数据结构-稀疏矩阵实验报告
实验报告
课程 学号 数据结构 姓名 实验名称 实验四 稀疏矩阵 实验日 期： 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.需求分析 (1)2.概要设计 (2)2.1链表对稀疏矩阵进行定义 (2)2.3程序一共有五个功能 (2)3.详细设计 (3)3.1稀疏矩阵存储算法分析 (3)3.2稀疏矩阵各运算算法分析 (3)4.调试分析 (8)4.1调试过程中的问题及解决方法 (8)4.2算法的时间复杂度和空间复杂 (8)4.3经验和体会 (8)5.用户使用说明 (9)6.测试结果 (10)6.1程序主界面 (10)6.2其他函数操作界面显示 (10)参考文献 (15)致谢 (16)1.需求分析矩阵在日常生活中应用广泛，尤其是有些特殊矩阵的运算。
但是在实际应用中有一种矩阵，在m×n的矩阵中有t个非零元素，且t远小于m×n，我们这样的矩阵被称为稀疏矩阵。
由于这类矩阵中通常零元素是没有规律的，为了能够找到相应的元素，仅存储非零元素的值是不行的，还要存储其所在的行和列等信息。
本程序主要的任务是创建稀疏矩阵，并且利用C++算法程序实现相应的运算（转置，加法，减法，乘法）（1）输入的形式以及范围：键盘输入符合要求的稀疏矩阵。
（2）输出形式：最终运算结果以矩阵的形式输出。
（3）程序功能实现：输入矩阵通过程序运算出相应的转置矩阵以及两个符合要求的矩阵的加减乘除法的运算。
（4）测试数据：如果输入正确，程序会显示最后的运算结果；否则错误时则会返回上层。
2.概要设计要存储稀疏矩阵并且进行运算，那么就要了解稀疏矩阵的存储结构，这里采用链表的形式存储稀疏矩阵并进行运算。
2.1链表对稀疏矩阵进行定义typedef struct OLNode{ // 定义链表元素int i,j;int e;struct OLNode *next; // 该非零元所在行表和列表的后继元素}OLNode,*OLink;typedef struct{ // 定义链表对象结构体OLink *head; //头指针int mu,nu,tu; // 行数，列数，和非零元素个数}CrossList;2.3程序一共有五个功能1.用CreateSMatrix_OL(M)函数来实现稀疏矩阵的存储，用OutPutSMatrix_OL(M)函数实现稀疏矩阵的输出。
数据结构实验报告稀疏矩阵运算
数据结构实验报告稀疏矩阵运算实验目的：1.学习并理解稀疏矩阵的概念、特点以及存储方式。
2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。
3.实现稀疏矩阵加法、乘法的算法，并进行性能测试和分析。
实验原理：稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。
在实际问题中，有许多矩阵具有稀疏性，例如文本矩阵、图像矩阵等。
由于存储稀疏矩阵时，对于大量的零元素进行存储是一种浪费空间的行为，因此需要采用一种特殊的存储方式。
常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。
其中，三元组顺序表是最简单直观的一种方式，它是将非零元素按行优先的顺序存储起来，每个元素由三个参数组成：行号、列号和元素值。
此外，还需要记录稀疏矩阵的行数、列数和非零元素个数。
稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历，对于相同位置的元素进行相加，得到结果矩阵。
稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算，即行乘以列的和。
实验步骤：1.实现稀疏矩阵的三元组顺序表存储方式，并完成稀疏矩阵的初始化、转置、打印等基本操作。
2.实现稀疏矩阵的加法运算，并进行性能测试和分析。
3.实现稀疏矩阵的乘法运算，并进行性能测试和分析。
4.编写实验报告。
实验结果：经过实验测试，稀疏矩阵的加法和乘法算法都能正确运行，并且在处理稀疏矩阵时能够有效节省存储空间。
性能测试结果表明，稀疏矩阵加法、乘法的运行时间与非零元素个数有关，当非零元素个数较少时，运算速度较快；当非零元素个数较多时，运算速度较慢。
实验分析：稀疏矩阵的运算相对于普通矩阵的运算有明显的优势，可以节省存储空间和运算时间。
在实际应用中，稀疏矩阵的存储方式和运算算法都可以进行优化。
例如，可以采用行逻辑链接表的方式存储稀疏矩阵，进一步减少存储空间的占用；可以采用并行计算的策略加快稀疏矩阵的运算速度。
总结：通过本次实验，我深入学习了稀疏矩阵的概念、特点和存储方式，掌握了稀疏矩阵加法、乘法的基本思想和算法，并通过实验实现了稀疏矩阵的加法、乘法运算。
数据结构实验报告稀疏矩阵运算
教学单位计算机科学与技术学生学号 5数据结构课程设计报告书题目稀疏矩阵运算器学生豹专业名称软件工程指导教师志敏实验目的：深入研究数组的存储表示和实现技术，熟悉广义表存储结构的特性。
需要分析：稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
要求以带“行逻辑信息”的三元组顺序表存储稀疏矩阵，实现两矩阵的相加、相减、相乘等运算。
输入以三元组表示，输出以通常的阵列形式列出。
软件平台：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）转置运算时输⼊三元组表：1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7得到转置后的三元组表：1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14（2）进⾏加法运算时先输⼊矩阵A（以三元组表形式）：1 1 12 2 22 3 43 1 -4输⼊矩阵B（以三元组表形式）：1 3 -22 3 -53 1 83 2 -6A与B的和矩阵以矩阵形式输出为：1 0 -20 2 -14 -6 0(⼆) 概要设计为了实现上述操作⾸先要定义三元组表，稀疏矩阵：typedef struct{int i,j;int e;}Triple;//三元组typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}Matrix;//稀疏矩阵1.基本操作void CreatMatrix(Matrix *m)操作结果：创建⼀个稀疏矩阵。
void PrintMatrix(Matrix m)初始条件：矩阵m已存在。
操作结果：将矩阵m以矩阵的形式输出。
void FastTransposeMatrix(Matrix a,Matrix *b)初始条件：稀疏矩阵a已存在；操作结果：将矩阵a进⾏快速转置后存⼊b中。
void AddMatrix(Matrix a,Matrix b,Matrix *c)初始条件：稀疏矩阵a和b都已存在；操作结果：将矩阵a和b的和矩阵存⼊c中。
稀疏矩阵编程实验报告
一、实验目的1. 理解稀疏矩阵的概念及其存储方式。
2. 掌握稀疏矩阵的基本操作，包括转置、加法、减法和乘法。
3. 通过编程实践，提高对数据结构和算法的理解和应用能力。
二、实验环境1. 编程语言：C语言2. 开发环境：Visual Studio 20193. 操作系统：Windows 10三、实验内容1. 稀疏矩阵的三元组表示及其实现2. 稀疏矩阵的转置3. 稀疏矩阵的加法、减法和乘法四、实验步骤1. 稀疏矩阵的三元组表示及其实现（1）定义稀疏矩阵的三元组结构体：```ctypedef struct {int row; // 行号int col; // 列号double val; // 非零元素值} Triple;```（2）定义稀疏矩阵结构体：typedef struct {int rows; // 矩阵行数int cols; // 矩阵列数int nums; // 非零元素个数Triple data; // 非零元素的三元组数组} SparseMatrix;```（3）编写函数实现稀疏矩阵的创建：```cvoid createSparseMatrix(SparseMatrix sm, int rows, int cols, int nums) { sm->rows = rows;sm->cols = cols;sm->nums = nums;sm->data = (Triple )malloc(nums sizeof(Triple));}```（4）编写函数实现稀疏矩阵的销毁：```cvoid destroySparseMatrix(SparseMatrix sm) {free(sm->data);sm->data = NULL;}2. 稀疏矩阵的转置（1）编写函数实现稀疏矩阵的转置：```cvoid transposeSparseMatrix(SparseMatrix src, SparseMatrix dst) {dst->rows = src->cols;dst->cols = src->rows;dst->nums = src->nums;dst->data = (Triple )malloc(src->nums sizeof(Triple));for (int i = 0; i < src->nums; i++) {dst->data[i].row = src->data[i].col;dst->data[i].col = src->data[i].row;dst->data[i].val = src->data[i].val;}}```3. 稀疏矩阵的加法、减法和乘法（1）编写函数实现稀疏矩阵的加法：```cvoid addSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val + sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val += sm2->data[j].val;}}}}}```（2）编写函数实现稀疏矩阵的减法：```cvoid subSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val - sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val -= sm2->data[j].val;}}}}}```（3）编写函数实现稀疏矩阵的乘法：```cvoid mulSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm2->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].col == sm2->data[j].row) {double sum = 0;for (int k = 0; k < sm1->nums; k++) {if (sm1->data[k].col == sm2->data[j].row) {sum += sm1->data[k].val sm2->data[j].val;}}if (sum != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val = sum;}}}}}```五、实验结果与分析1. 通过编程实现稀疏矩阵的基本操作，验证了算法的正确性。
《数据结构 课程设计》稀疏矩阵实验报告
(2)稀疏矩阵的相加：
void MatrixAdd(int A[max],int B[max],int C[max]),这个函数用 于实现数组A和数组B的相加，并将其相加的结果存入数组C。这个函数 讨论了数组在相加的过程中的几种情况： a、 A数组和B数组的行相等且列相等，两者直接相加后存入数组C中。 if(A[i]==B[j]) { if(A[i+1]==B[j+1]) { C[k]=A[i]; C[k+1]=A[i+1]; C[k+2]=A[i+2]+B[j+2]; k=k+3; i=i+3; j=j+3; } } b、A的列小于B的列，将A的三个元素直接存入C中
2、 系统分析
稀疏矩阵的保存：以一位数组顺序存放非零元素的行号、列号和数 值，行号为-1作为结束符。以三个一维数组存放一个系数矩阵中的一个 非零元素，为零额元素则不保存。用一个二重循环来实现判断每个系数
矩阵的非零元素是否为零，不为零，就将其行列下标和其值存入一维数 组中 稀疏矩阵的相加：用循环来判断存储A何B稀疏矩阵的两个一维数组 中的行列下标是否相等和其大小关系。若相等，则将两个一维数组的第 三个元素的值相加存入新的数组C里，行列下标不变的存入进去；若A的 列小于B的列，则将A的三个元素直接存入C中；若B的列小于A的列，则 将B的三个元素村日C中；若A的行小于B的行，则将A的三个元素存入C 中；若A的行大于B的行，则将B存入C中。
3、 概要设计
（1)主界面的设计:
定义两个矩阵a= 0 0 0 0 0 0 0 0 0 0 0 9 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 b= 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 1 0 0 4 0 0 0 0 0 0 0 8 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
实现稀疏矩阵的基本运算实验报告
实现稀疏矩阵的基本运算实验报告实验报告：稀疏矩阵的基本运算实验一、引言稀疏矩阵是指在矩阵中大部分元素为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、掌握稀疏矩阵的存储方式；2、掌握稀疏矩阵的快速转置算法；3、进一步了解和巩固线性表和链表的相关知识。
二、实验内容1、根据课本内容和参考资料，设计两种不同的存储稀疏矩阵的结构体，并分别实现稀疏矩阵的快速转置操作；2、实现输出稀疏矩阵、打印转置后的稀疏矩阵、以及转置前后两个稀疏矩阵在内存中的存储情况。
三、实验原理1、稀疏矩阵的存储稀疏矩阵指的是矩阵中绝大多数元素为零的矩阵，依据存储方式，目前主要有两种实现方法：顺序表和链表。
（1）顺序表顺序表的存储方式如下：typedef struct{int arr[MAXSIZE]; // 一维数组表示矩阵int rows; // 矩阵共有 rows 行int cols; // 矩阵共有 cols 列int nums; // 矩阵中不为零的元素共有 nums 个}TSMatrix;其中，数组 arr 的长度为 MAXSIZE，每个元素保存矩阵中某个元素的值，且元素的下标按行优先排列，例如，在一个5×5 的矩阵中，a23 可以表示成 a[(2-1)×5+3-1]，其中 2-1 代表该元素所在行的下标，3-1 代表该元素所在列的下标。
（2）链表链式存储的特点在于元素之间存在指针联系，节点中保存三元组（row、col、val），其中 row 表示该元素所在的行，col 表示该元素所在的列，val 表示该元素的值，next 指针表示该元素的下一个节点。
2、稀疏矩阵转置稀疏矩阵转置的基本思想是将原矩阵中非零元素的行和列对换。
转置后的矩阵中行和列的值对应变换，对应的非零元素也跟着变化。
1、初始化转置矩阵；2、遍历原矩阵中的元素，将其转置后按行优先的顺序插入转置矩阵；3、输出转置矩阵。
链表转置的步骤如下：四、实验步骤1、根据上述原理，设计 2 种结构体 TSMatrix 和 LinkMatrix，分别完成快速转置算法；2、封装 tranverse_TMatrix 和 tranverse_LinkMatrix 两个函数，并设计测试用例验证结果。
数据结构_实验四_字符串、稀疏矩阵实验
实验编号：4四川师大《数据结构》实验报告2016年11月12日实验四字符串、稀疏矩阵实验_一．实验目的及要求（1）熟悉字符串类型的实现方法，并完成串的一些基本操作；（2）掌握稀疏矩阵的三元组顺序表存储表示，并实现矩阵的转置运算。
二．实验内容（1）编程实现两个串S1和S2的比较。
（要求自己设计串的存储结构，并编写比较函数，不要调用系统提供的函数）（2）编程实现稀疏矩阵的三元组顺序表示方法及基本操作的实现（建立、输出、转置等）。
（3）编程实现稀疏矩阵的十字链表存储表示及基本操作的实现（建立、输出等）。
注：（2）必做，（1）（3）选做。
三．主要仪器设备及软件（1）PC机（2）Dev C++ ,Visual C++, VS2010等四．实验主要流程、基本操作或核心代码、算法片段（该部分如不够填写，请另加附页）（1）编程实现两个串S1和S2的比较。
（要求自己设计串的存储结构，并编写比较函数，不要调用系统提供的函数）➢代码部分：//Main.cpp:#include"SString.h"int main(){SString T1,T2;int i,n;T1[0]=T2[0]=0;cout<<"input T1 size:";cin>>n;T1[0]=n;cout<<"input T1 data:";for(i=1;i<=n;i++){cin>>T1[i];}cout<<"input T2 size:";cin>>n;T2[0]=n;cout<<"input T2 data:";for(i=1;i<=n;i++){cin>>T2[i];}cout<<"T1"<<Compare(T1,T2)<<"T2"<<endl;return 0;}//SString.cpp:#include"SString.h"char Compare(SString T1,SString T2){if(T1[0]>T2[0]){return '>';}else if(T1[0]<T2[0]){return '<';}else{for(int i=1;i<=T1[0];i++){if(T1[i]>T2[i]){return '>';}else if(T1[i]<T2[i]){return '<';}}}return '=';}//SString.h:#include<iostream>using namespace std;const int MAX=255;typedef unsigned char SString[MAX+1];char Compare(SString T1,SString T2);➢运行结果：（2）编程实现稀疏矩阵的三元组顺序表示方法及基本操作的实现（建立、输出、转置等）。
《数据结构 课程设计》稀疏矩阵实验报告
目录一、概述 (1)二、系统分析 (1)三、概要设计 (1)（1)主界面的设计: (2)（2）系数矩阵的存储 (2)（3）具体实现流程图： (3)四、详细设计 (4)(2)稀疏矩阵的相加： (5)五、运行与测试 (8)六、总结与心得 (9)参考文献 (9)源代码 (9)一、概述稀疏矩阵的加法运算，既将稀疏矩阵A和B，他均为m行n列，分别以数组的形式存放在A和B中，实现A+B=C，将所得的结果存放在C数组中。
二、系统分析稀疏矩阵的保存：以一位数组顺序存放非零元素的行号、列号和数值，行号为-1作为结束符。
以三个一维数组存放一个系数矩阵中的一个非零元素，为零额元素则不保存。
用一个二重循环来实现判断每个系数矩阵的非零元素是否为零，不为零，就将其行列下标和其值存入一维数组中稀疏矩阵的相加：用循环来判断存储A何B稀疏矩阵的两个一维数组中的行列下标是否相等和其大小关系。
若相等，则将两个一维数组的第三个元素的值相加存入新的数组C里，行列下标不变的存入进去；若A的列小于B的列，则将A的三个元素直接存入C中；若B的列小于A的列，则将B的三个元素村日C中；若A的行小于B的行，则将A的三个元素存入C中；若A的行大于B的行，则将B存入C中。
三、概要设计（1)主界面的设计:定义两个矩阵a= 0 0 3 0 0 0 0 0 b= 0 2 0 0 0 0 0 00 0 0 0 0 0 5 0 0 0 0 4 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 6 0 00 0 0 0 7 0 0 0 0 0 0 0 8 0 0 00 0 0 0 0 0 0 0 0 0 1 0 0 0 0 00 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0定义两个数组A和B，用于存储矩阵a和矩阵b的值；定义一个数组C，用于存放数组A和数组B相加后的结果。
（2）系数矩阵的存储用一维数组存放系数矩阵A如下：A[0]=0，A[1]=2, A[2]=3, A[3]=1, A[4]=6, A[5]=5, A[6]=3, A[7]=4, A[8]=7, A[9]=5, A[10]=1, A[11]=9, A[12]=-1。
数据结构稀疏矩阵基本运算实验报告
课程设计课程：数据结构题目：稀疏矩阵4 三元组单链表结构体(行数、列数、头) 矩阵运算重载运算符优班级：姓名：学号：设计时间：2010年1月17日——2010年5月XX日成绩：指导教师：楼建华一、题目二、概要设计1.存储结构typedef struct{int row,col;//行，列datatype v;//非0数值}Node;typedef struct{Node data[max];//稀疏矩阵int m,n,t;//m 行，n 列，t 非0数个数……2.基本操作⑴istream& operator >>(istream& input,Matrix *A)//输入⑵ostream& operator <<(ostream& output,Matrix *A){//输出⑶Matrix operator ~(Matrix a,Matrix b)//转置⑷Matrix operator +(Matrix a,Matrix b)//加法⑸Matrix operator -(Matrix a,Matrix b)//减法⑹Matrix operator *(Matrix a,Matrix b)//乘法⑺Matrix operator !(Matrix a,Matrix b)//求逆三、详细设计（1）存储要点position[col]=position[col-1]+num[col-1];三元组表(row ，col ，v)稀疏矩阵（（行数m ，列数n ，非零元素个数t ），三元组，...，三元组）1 2 3 4 max-1（2）乘法运算要点已知稀疏矩阵A(m1× n1)和B(m2× n2)，求乘积C(m1× n2)。
稀疏矩阵A、B、C及它们对应的三元组表A.data、B.data、C.data如图6所示。
由矩阵乘法规则知：C(i，j)=A(i,1)×B(1,j)+A(i,2)×B(2,j)+…+A(i,n)×B(n,j)=这就是说只有A(i,k)与B(k,p)(即A元素的列与B元素的行相等的两项)才有相乘的机会，且当两项都不为零时，乘积中的这一项才不为零。
稀疏矩阵实验报告
一、实验目的1. 理解稀疏矩阵的概念和特点。
2. 掌握稀疏矩阵的三元组表示方法。
3. 熟悉稀疏矩阵的基本运算，如转置、加法、减法等。
4. 提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 稀疏矩阵的三元组表示- 设计稀疏矩阵的三元组存储结构。
- 编写函数实现稀疏矩阵的三元组表示。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置。
- 实现稀疏矩阵的加法、减法。
- 实现稀疏矩阵的乘法。
3. 实验结果分析- 对实验结果进行分析，比较稀疏矩阵与普通矩阵运算的效率。
四、实验步骤1. 稀疏矩阵的三元组表示- 定义稀疏矩阵的三元组存储结构，包括行号、列号和元素值。
- 编写函数实现稀疏矩阵的三元组表示，包括读取稀疏矩阵的三元组数据、构建稀疏矩阵的三元组表示等。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置，包括交换行号和列号、重新排序等。
- 实现稀疏矩阵的加法、减法，包括遍历两个稀疏矩阵的三元组，计算对应元素的加法或减法结果。
- 实现稀疏矩阵的乘法，包括遍历两个稀疏矩阵的三元组，计算对应元素的乘法结果。
3. 实验结果分析- 对实验结果进行分析，比较稀疏矩阵与普通矩阵运算的效率。
- 分析实验结果，得出稀疏矩阵运算的优缺点。
五、实验结果1. 稀疏矩阵的三元组表示- 读取稀疏矩阵的三元组数据，构建稀疏矩阵的三元组表示。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置，包括交换行号和列号、重新排序等。
- 实现稀疏矩阵的加法、减法，包括遍历两个稀疏矩阵的三元组，计算对应元素的加法或减法结果。
- 实现稀疏矩阵的乘法，包括遍历两个稀疏矩阵的三元组，计算对应元素的乘法结果。
3. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高，尤其在稀疏程度较高的矩阵上。
- 稀疏矩阵运算的缺点是存储空间较大，且运算过程中需要频繁进行数据交换。
数据结构实验报告实验五稀疏矩阵运算器
一、引言稀疏矩阵是一个具有大量零元素的矩阵，对于大规模的矩阵来说，如果没有充分利用矩阵的稀疏性质，将会带来很大的存储空间和计算时间上的浪费。
为了解决这个问题，我们需要通过设计一个稀疏矩阵运算器来对稀疏矩阵进行各种运算，以提高计算效率。
二、实验目标本实验的主要目标是设计一个稀疏矩阵运算器，通过实现对稀疏矩阵的加法、乘法和转置等操作，实现对稀疏矩阵的高效运算。
三、设计思路和方法1. 矩阵的表示方式在设计稀疏矩阵运算器时，我们需要选择合适的数据结构来表示稀疏矩阵。
由于稀疏矩阵中大部分元素为零，我们可以采用压缩存储的方法来表示稀疏矩阵。
一种常用的压缩存储方法是使用三元组表示法，即将矩阵的非零元素的值、所在的行号和列号分别存储在一个三元组中。
2. 加法运算稀疏矩阵的加法运算是指将两个稀疏矩阵进行对应位置的相加操作。
在进行稀疏矩阵的加法运算时，首先需要判断两个矩阵的维度是否相同，然后通过遍历两个矩阵的非零元素，将相同位置的元素进行相加得到结果。
3. 乘法运算稀疏矩阵的乘法运算是指将两个稀疏矩阵进行矩阵乘法操作。
在进行稀疏矩阵的乘法运算时，首先需要判断第一个矩阵的列数是否等于第二个矩阵的行数，然后通过遍历两个矩阵的非零元素，按照行和列的顺序对应相乘，再将相乘的结果加到结果矩阵中。
4. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。
在进行稀疏矩阵的转置运算时，只需要将矩阵的非零元素的行号和列号对换即可。
五、实验结果与分析我们在实现稀疏矩阵运算器后，对其进行了测试。
通过测试，我们发现稀疏矩阵运算器能够正确地进行稀疏矩阵的加法、乘法和。
实现稀疏矩阵采用三元组表示的基本运算实验报告
实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（1）生成如下两个稀疏矩阵的三元组a 和 b；（上机实验指导 P92 ）（2）输出 a 转置矩阵的三元组；（3）输出a + b 的三元组；（4）输出 a * b 的三元组；三实验内容:3.1 稀疏矩阵的抽象数据类型:ADT SparseMatrix {数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;ai,j∈ElemSet,m 和n分别称为矩阵的行数和列数 }数据关系 : R={ Row , Col }Row ={<ai,j ,ai,j+1> | 1≤ i≤m , 1≤ j ≤ n-1}Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}基本操作:CreateSMatrix(&M)操作结果：创建稀疏矩阵M PrintSMatrix(M)初始条件：稀疏矩阵M已经存在操作结果：打印矩阵M DestroySMatrix(&M)初始条件：稀疏矩阵M已经存在操作结果：销毁矩阵M CopySMatrix(M, &T)初始条件：稀疏矩阵M已经存在操作结果：复制矩阵M到TAddSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的和Q=M+N SubSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件：稀疏矩阵M已经存在操作结果：求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件：稀疏矩阵M已经存在操作结果：求矩阵的积Q=M*N }ADT SparseMatrix3.2存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 //矩阵中非零元素最多个数typedef struct{ int r; //行号int c; //列号ElemType d; //元素值} TupNode; //三元组定义typedef struct{ int rows; //行数值int cols; //列数值int nums; //非零元素个数TupNode data[MaxSize];} TSMatrix; //三元组顺序表定义3.3基本操作实现:void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nu ms].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows ,t.cols,t.nums);printf("\t------------------\n ");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i] .r,t.data[i].c,t.data[i].d);3.4解题思路：1.转置矩阵：只要判定原矩阵有值，那么只要遍历一遍原矩阵，把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。
数据结构实验四稀疏矩阵运算
数据结构实验四稀疏矩阵运算1、实验目的掌握三元组法存储稀疏矩阵的方法及相关的基本操作。
2、实验内容∙用三元组法存放稀疏矩阵∙求出矩阵转置结果∙求出矩阵相乘结果∙输出结果矩阵3、实验要求∙用数组存放矩阵的三元组，矩阵的行数和列数及非0数据从键盘输入∙要求采用稀疏矩阵快速转置算法∙若两个矩阵不能相乘则输出“Error”4、试验参考程序typedef s tr uct { // 定义三元组的元素int i, j;int e;} Tr iple;typedef s tr uct { // 定义矩阵Tr iple data[MA XSI ZE + 1];int mu, nu, tu;} TSMa tr ix;typedef s tr uct { // 定义行逻辑连接矩阵Tr iple data[MA XSI ZE + 2];int rpos[MA XROW + 1];int mu, nu, tu;} RLSMatr ix;矩阵输入函数bool InPutT SMat r ix(T SMatr ix & T) {cout << "输入矩阵的行，列和非零元素个数:" << e ndl;cin >> T.mu >> T.nu >> T.tu;cout << "请输出非零元素的位置和值:" << e ndl;for (int k = 1;; k <= T.t u; k++)cin >> T.data[k].i >> T.da ta[k].j >> T.data[k].e;retur n t rue;}请补充完成下列矩阵转置函数、矩阵乘法函数与矩阵输出函数Bool Trans poseSMa tr ix(T SMa t r ix M, T SMat r ix & T){TSMatrix M,T; //定义预转置的矩阵InPutTSMatrix(M, 0); //输入矩阵int num[MAXROW+1];int cpot[MAXROW+1]; // 构建辅助数组int q,p,t;T.tu=M.tu; T.mu=M.nu; T.nu=M.mu;if(T.tu){for(int col=1;col<=M.nu;col++) num[col]=0;for(t=1;t<=M.tu;t++) ++num[M.data[t].j];cpot[1]=1;for(int i=2;i<=M.nu;i++) cpot[i]=cpot[i-1]+num[i-1]; // 求出每一列中非零元素在三元组中出现的位置for(p=1;p<=M.tu;p++){col=M.data[p].j; q=cpot[col];T.data[q].i=col; T.data[q].j=M.data[p].i;T.data[q].e=M.data[p].e; ++cpot[col];}}cout<<"输入矩阵的转置矩阵为"<<endl;OutPutSMatrix(T);return true;}Bool MultSMatr ix(RLSMatr ix M, RL SMatr ix N，RL SMat r ix & T){RLSMatrix M,N,Q; // 构建三个带“链接信息”的三元组表示的数组InPutTSMatrix(M,1); // 用普通三元组形式输入数组InPutTSMatrix(N,1);Count(M); Count(N);if(M.nu!=N.mu) return false;Q.mu=M.mu; Q.nu=N.nu; Q.tu=0; // Q初始化int ctemp[MAXROW+1]; // 辅助数组int arow,tp,p,brow,t,q,ccol;if(M.tu*N.tu){ // Q是非零矩阵for( arow=1;arow<=M.mu;arow++){///memset(ctemp,0,N.nu);for(int x=1;x<=N.nu;x++) // 当前行各元素累加器清零ctemp[x]=0;Q.rpos[arow]=Q.tu+1; // 当前行的首个非零元素在三元组中的位置为此行前所有非零元素+1 if(arow<M.mu) tp=M.rpos[arow+1];else tp=M.tu+1;for(p=M.rpos[arow];p<tp;p++){ // 对当前行每个非零元素进行操作brow=M.data[p].j; // 在N中找到i值也操作元素的j值相等的行if(brow<N.mu) t=N.rpos[brow+1];else t=N.tu+1;for(q=N.rpos[brow];q<t;q++){ // 对找出的行当每个非零元素进行操作ccol=N.data[q].j;ctemp[ccol] += M.data[p].e*N.data[q].e; // 将乘得到对应值放在相应的元素累加器里面}}for(ccol=1;ccol<=Q.nu;ccol++) // 对已经求出的累加器中的值压缩到Q中if(ctemp[ccol]){if(++Q.tu>MAXSIZE) return false;Q.data[Q.tu].e=ctemp[ccol];Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;}}OutPutSMatrix(Q);return true;}}boo l O utP utSMatrix(T SMat r ix T){// 输出矩阵，按标准格式输出int m,n,k=1;fo r(m=0;m<T.mu;m++){fo r(n=0;n<T.nu;n++){if((T.d a ta[k].i-1)==m&&(T.d a ta[k].j-1)==n){co ut.w id th(4);co ut<<T.d a ta[k++].e;}e ls e{co ut.w id th(4); co ut<<"0"; }}co ut<<e nd l;}re turn true;}}并建立ma in（）函数对上述函数进行测试。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
教学单位计算机科学与技术学生学号 5数据结构课程设计报告书题目稀疏矩阵运算器学生豹专业名称软件工程指导教师志敏实验目的：深入研究数组的存储表示和实现技术，熟悉广义表存储结构的特性。
需要分析：稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
要求以带“行逻辑信息”的三元组顺序表存储稀疏矩阵，实现两矩阵的相加、相减、相乘等运算。
输入以三元组表示，输出以通常的阵列形式列出。
软件平台：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();}小结：。