数据结构----稀疏矩阵运算器课程设计报告书

合集下载

稀疏矩阵运算器实验报告

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;

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

数据结构实验报告三稀疏矩阵的运算实验课程名称数据结构课程设计专业班级学⽣姓名学号指导教师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;}五：运⾏与测试进⾏数据测试六：总结与⼼得⼗字链表作为存储结构表⽰随机稀疏矩阵，进⾏两矩阵的相加运算，所以⾸先要定义⼀个⼗字链表作为存储结构。

稀疏矩阵运算器-数据结构课程设计

实习4、稀疏矩阵运算器一、需求分析1. 问题描述稀疏矩阵是指那些多数元素为零的矩阵。

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

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

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

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

3. 实现提示(1)首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否匹配。

可设聚矩阵的行数和列数不超过20。

(2)程序可以对三元组的输入顺序加以限制，例如，按行优先。

注意研究教科书5.3.2节中的算法，以便提高计算效率。

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

二、概要设计ADT SparseMatrix{数据对象：D={a ij |i=1,2,3……m;j = 1,2,3……n;a i,j ∈intSet,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,j+1>|1≤i ≤m-1，1≤j ≤n}基本操作：CreateSMatrix(*T);操作结果：创建稀疏矩阵T 。

AddRLSMatrix(M,N,*Q);初始条件：稀疏矩阵M 和N 的行数列数对应相等。

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

SubRLSSMatrix(M,N,*Q);初始条件：稀疏矩阵M 和N 的行数列数对应相等。

操作结果：求稀疏矩阵的差Q=M-N 。

SMatrixrpos(*T)初始条件：稀疏矩阵T 存在。

操作结果：求稀疏矩阵的各行第一个非零元的位置表。

MulTSMatrix(M,N,*Q);初始条件：稀疏矩阵M 的列数与N 的行数对应相等。

三元组顺序表稀疏矩阵课程设计报告(不完整)

1.稀疏矩阵运算器数据结构课程设计任务书针对本课程设计，完成以下课程设计任务：1、熟悉系统实现工具和上机环境。

2、根据课程设计任务，查阅相关资料。

3、针对所选课题完成以下工作：（1）需求分析（2）概要分析（3）详细设计（4）编写源程序（5）静态走查程序和上机调试程序4、书写上述文档和撰写课程设计报告。

3.课程设计报告目录4.正文（1）问题描述稀疏矩阵是指那些多数元素为零的矩阵。

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

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

（2）需求分析本课程设计的稀疏矩阵运算器在visual studio 2013下运行调试成功，可以实现的功能有：1.矩阵运算方式选择2.根据提示输入相应数据3.显示最终结果使用的主要存储结构为三元组，并用三元组形式进行运算。

所有参与运算数据类型为整形，因此输入的数据应为整形数据。

为了节省存储空间使用三元组数据进行运算，可以通过多次扫描三元组数据来实现，即使用嵌套循环函数。

输出结果为通常的阵列形式，因此使用了右对齐，保证输出形式的整齐。

（3）概要分析本次课程设计中定义的结构体typedef struct {int i, j;//矩阵元素所在行列int v;//元素的值}triple;typedef struct {triple data[MAXSIZE];triple cop[MAXSIZE];//辅助数组int m, n, t;//矩阵的行列数}tripletable;Main函数调用子函数时输入1为调用int Push_juzhen(int m, int n, int count)函数，可以实现矩阵相加功能输入2为调用int Dec_juzhen(int m, int n, int count)函数，可实现矩阵相减功能输入3为调用int Mul_juzhen()函数，可以实现矩阵相乘功能（4）详细分析（流程图伪代码）加法函数int Push_juzhen(int m, int n, int count)//矩阵相加（行，列，矩阵数）{// p行，q列，s非零元素个数，v元素值//ucount对数组下标计数的变量，与变量x实现多个矩阵相加for (int c = 0; c < count; c++){int x = 0;cout << "请输入第" << c + 1 << "个矩阵的非零元素个数" << endl;cin >> s;cout << "请依次输入非零元素所在行和列以及该非零元素的值并以空格隔开" << endl;for (; x< s; x++)//传递行列及元素值{cin >> p >> q >> v;a.cop[x].i = p;//将p赋值给data[x].ia.cop[x].j = q;//将q赋值给data[x].ja.cop[x].v = v;//将v赋值给data[x].v}//g行//h列for (int g = 1; g <= m;g++)for (int h = 1; h <= n; h++){int l;//存储下标for (l = 0; l < s; l++)//对辅助存储中的三元组进行行逻辑排序，将数据存入a.data{if (a.cop[l].i == g&&a.cop[l].j == h){a.data[u].i = a.cop[l].i;a.data[u].j = a.cop[l].j;a.data[u].v = a.cop[l].v;u++;}}}}//矩阵相加//k为行数//h为列数for (int k = 0; k < u; k++){for (int h = 0; h <= ucount; h++){if (a.data[k].i == b.data[h].i&&a.data[k].j == b.data[h].j)//判断行列是否相等b.data[h].v += a.data[k].v;else{b.data[ucount].i = a.data[k].i;b.data[ucount].j = a.data[k].j;b.data[ucount].v = a.data[k].v;ucount++;//存储空间增加计数}break;//增加一组数据时跳出循环，避免重复计算}}return 0;}相减函数int Dec_juzhen(int m, int n, int count){for (int c = 0; c < count; c++){int x = 0;cout << "请输入第" << c + 1 << "个矩阵的非零元素个数" << endl;cin >> s;cout << "请依次输入非零元素所在行和列以及该非零元素的值并以空格隔开" << endl;for (; x< s; x++)//传递行列及元素值{cin >> p >> q >> v;a.cop[x].i = p;//将p赋值给data[x].ia.cop[x].j = q;//将q赋值给data[x].ja.cop[x].v = v;//将v赋值给data[x].v}//g行//h列if (c != 0){for (int g = 1; g <= m; g++)for (int h = 1; h <= n; h++){int l;//存储下标for (l = 0; l < s; l++)//行逻辑排列{if (a.cop[l].i == g&&a.cop[l].j == h){ a.data[u].i = a.cop[l].i;a.data[u].j = a.cop[l].j;a.data[u].v =- a.cop[l].v;//c>0时为减数矩阵u++;}}}}else{for (int g = 1; g <= m; g++)for (int h = 1; h <= n; h++){int l;//存储下标for (l = 0; l < s; l++){if (a.cop[l].i == g&&a.cop[l].j == h){a.data[u].i = a.cop[l].i;a.data[u].j = a.cop[l].j;a.data[u].v = a.cop[l].v;u++;}}}}}//矩阵减法计算for (int k = 0; k < u; k++){for (int h = 0; h <= ucount; h++){if (a.data[k].i == b.data[h].i&&a.data[k].j == b.data[h].j)//判断行列相等b.data[h].v += a.data[k].v;else{b.data[ucount].i = a.data[k].i;b.data[ucount].j = a.data[k].j;b.data[ucount].v = a.data[k].v;ucount++;}break;}}return 0;}相乘函数int Mul_juzhen(){cout << "请输入第一个矩阵的行列数" << endl;cin >> m >> n;cout << "请输入第一个矩阵的非零元素个数" << endl;cin >> t1;a.m = m;a.n = n;a.t = t1;cout << "请输入第一个矩阵的非零元素所在的行、列、数值并以空格间隔" << endl;for (i=0; i < t1; i++){cin >> p >> q >> v;a.data[i].i = p;//将p赋值给data[x].ia.data[i].j = q;//将q赋值给data[x].ja.data[i].v = v;//将v赋值给data[x].v}cout << "则第二个矩阵的行数为" << a.n << "行" << endl<<endl;cout << "请输入第二个矩阵的列数" << endl;cin >> n;cout << "请输入第二个矩阵的非零元素个数" << endl;cin >> t2;b.m = a.n;b.n = n;b.t = t2;cout << "请输入第二个矩阵的非零元素所在的行、列、数值并以空格间隔" << endl;for (i = 0; i < t2; i++){cin >> p >> q >> v;b.data[i].i = p;//将p赋值给data[x].ib.data[i].j = q;//将q赋值给data[x].jb.data[i].v = v;//将v赋值给data[x].v}i = 0;//i为a、b数组标记，另设k为矩阵相乘元素扫描标记//n为检测相加元素扫描标记，z为存储标记while (i < a.t){int k;for (k = 0; k < b.t; k++){if (a.data[i].j == b.data[k].i)if (i>0){for (n = 0; n < z; n++){if (a.data[i].i == c.data[n].i&&b.data[k].j == c.data[n].j)//判断是否符合相加条件c.data[n].v += a.data[i].v*b.data[k].v;else{c.data[z].i = a.data[i].i;c.data[z].j = b.data[k].j;c.data[z].v = a.data[i].v*b.data[k].v;z++;}}}else{c.data[z].i = a.data[i].i;c.data[z].j= b.data[k].j;c.data[z].v = a.data[i].v*b.data[k].v;z++;}}i++;}return 0;}（5）调试分析（遇到的问题，修改，解决办法，时空复杂度）刚开始，程序仅使用三元组存储，计算过程使用了二维数组，但矩阵相乘会出现错误，矩阵乘法时间复杂度为矩阵一的行数乘以矩阵二的列数（m1*n2）。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4.编写实验报告。

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

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

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

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

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

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

数据结构稀疏矩阵运算器课程设计

数据结构----稀疏矩阵运算器课程设计目录稀疏矩阵运算器设计............................................................................................ I摘要................................................................................................................ ... II第一章需求分析 (1)第二章概要设计 (2)第三章设计步骤 (6)3.1 函数说明 (6)3.2 设计步骤 (7)第四章设计理论分析方法 (20)4.1 算法一：矩阵转置.....................................................................204.2 算法二：矩阵加法.....................................................................204.3 算法三：矩阵乘法 (21)第五章程序调试 (23)第六章心得体会 (25)参考文献 (26)第一章需求分析1．稀疏矩阵是指那些多数元素为零的矩阵。

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

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

2．以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现矩阵转置，求逆，实现两个矩阵相加、相减和相乘的运算。

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

3．演示程序以用户和计算机的对话方式执行，数组的建立方式为边输入边建立。

4．由题目要求可知：首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。

5．程序可以对三元组的输入顺序不加以限制；根据对矩阵的行列，三元组作直接插入排序，从而进行运算时,不会产生错误。

稀疏矩阵(算法与数据结构课程设计)

稀疏矩阵一、问题描述假若在n m ⨯阶中，有t 个元素不为零，令nm t ⨯=δ称为矩阵的稀疏因子。

通常认为≤δ0.05时称为稀疏矩阵。

稀疏矩阵的研究大大的减少了数据在计算机中存储所需的空间，然而，它们的运算却与普通矩阵有所差异。

通过本次实验实现稀疏矩阵的转置、加法和乘法等多种运算。

二、基本要求1、稀疏矩阵采用三元组表示，建立稀疏矩阵，并能按矩阵和三元组方式输出;2、编写算法，完成稀疏矩阵的转置操作；3、编写算法，完成对两个具有相同行列数的稀疏矩阵进行求和操作；4、编写算法，对前一矩阵行数与后一矩阵列数相等的两个矩阵,完成两个稀疏矩阵的相乘操作。

三、测试数据1、转置操作的测试数据：⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200013000010020100 2、相加操作的测试数据： ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200013000010020100 ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200010000210030300 3、相乘操作的测试数据： ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛0000000300400021 ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛001002000021 四、算法思想1、三元组结构类型为Triple ，用i 表示元素的行，j 表示元素的列，e 表示元素值。

稀疏矩阵的结构类型为TSMatrix ，用数组data[]表示三元组，mu 表示行数，nu 表示列数，tu 表示非零元个数。

2、稀疏矩阵转置的算法思想将需要转置的矩阵a 所有元素存储在三元组表a.data 中，按照矩阵a 的列序来转置。

为了找到a的每一列中所有非零元素，需要对其三元组表a.data扫描一遍，由于a.data 是以a的行需序为主序来存放每个非零元的，由此得到的就是a的转置矩阵的三元组表，将其储存在b.data中。

3、稀疏矩阵相加的算法思想比较满足条件(行数及列数都相同的两个矩阵)的两个稀疏矩阵中不为0的元素的行数及列数（即i与j），将i与j都相等的前后两个元素值e相加，保持i,j不变储存在新的三元组中，不等的则分别储存在此新三元组中。

数据结构课程设计稀疏矩阵

稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。

在程序设计中，考虑到方法的难易程度，采用了先用三元组实现稀疏矩阵的输入，输出，及其转置，相加，相乘操作的方法，再在十字链表下实现。

程序通过调试运行，结果与预期一样，初步实现了设计目标。

关键词程序设计；稀疏矩阵；三元组；十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。

稀疏矩阵采用三元组和十字链表表示，并在两种不同的存储结构下，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；求出A的转置矩阵D，输出D；求两个稀疏矩阵A和B的相乘矩阵E，并输出E。

1.2课程设计性质数据结构课程设计是重要地实践性教学环节。

在进行了程序设计语言课和《数据结构》课程教学的基础上，设计实现相关的数据结构经典问题，有助于加深对数据结构课程的认识。

本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现，包括在三元组和十字链表下存储稀疏矩阵，并对输入的稀疏矩阵进行转置，相加，相乘等操作，最后把运算结果输出。

此课程设计要求对数组存储结构和链表存储结构非常熟悉，并能熟练使用它们。

1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上，掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置，相加，相乘等基本操作，并用不同的方法输出结果，进一步掌握设计、实现较大系统的完整过程，包括系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及操作方法，为进一步的应用开发打好基础。

2需求分析2.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. 简介1.1 概述1.2 稀疏矩阵的定义2. 数据结构设计2.1 稀疏矩阵的存储方式2.2 稀疏矩阵的数据结构设计3. 基本操作3.1 创建稀疏矩阵3.2 初始化稀疏矩阵的元素3.3 稀疏矩阵的加法3.4 稀疏矩阵的减法3.5 稀疏矩阵的乘法4. 高级操作4.1 稀疏矩阵的转置4.2 稀疏矩阵的快速乘法5. 示例应用5.1 矩阵乘法示例5.2 矩阵转置示例6. 总结与展望1. 简介1.1 概述稀疏矩阵是一种具有大量零元素的矩阵，对于大规模稀疏矩阵的运算，传统的矩阵运算方法效率较低。

本文档介绍了一种稀疏矩阵运算器的设计和实现。

1.2 稀疏矩阵的定义稀疏矩阵是指矩阵中大部分元素为零的矩阵。

相比于密集矩阵，稀疏矩阵的存储和运算可以进行有效的优化，提高运算效率。

2. 数据结构设计2.1 稀疏矩阵的存储方式稀疏矩阵可以使用多种方式进行存储，常见的方法有三元组表示法和十字链表表示法。

本文档使用三元组表示法进行存储。

2.2 稀疏矩阵的数据结构设计稀疏矩阵的数据结构设计包括矩阵的行数、列数和非零元素的个数等基本信息，以及按照行优先的方式存储稀疏矩阵的非零元素和对应的行列索引。

3. 基本操作3.1 创建稀疏矩阵创建稀疏矩阵的操作包括输入矩阵的行数和列数，以及非零元素的个数，以便为矩阵分配内存空间。

3.2 初始化稀疏矩阵的元素初始化稀疏矩阵的操作包括输入矩阵的非零元素及其对应的行列索引。

3.3 稀疏矩阵的加法实现稀疏矩阵的加法运算，包括对两个稀疏矩阵进行相应的遍历和运算操作。

3.4 稀疏矩阵的减法实现稀疏矩阵的减法运算，包括对两个稀疏矩阵进行相应的遍历和运算操作。

3.5 稀疏矩阵的乘法实现稀疏矩阵的乘法运算，包括对两个稀疏矩阵进行相应的遍历和运算操作。

4. 高级操作4.1 稀疏矩阵的转置实现稀疏矩阵的转置操作，包括对稀疏矩阵的行列索引进行互换。

4.2 稀疏矩阵的快速乘法通过对矩阵进行合并和切分等操作，实现稀疏矩阵的快速乘法运算，提高运算效率。

《数据结构课程设计》稀疏矩阵实验报告

(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

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

数据结构课程设计《数据结构》课程设计一.题目：稀疏矩阵应用（限1 人完成）要求：实现三元组，十字链表下的稀疏矩阵的加、转、乘的实现。

（1）稀疏矩阵的存储（2）稀疏矩阵加法（3）矩阵乘法（4）矩阵转置二.算法思想描述：1．需求分析（1）设计函数建立稀疏矩阵，初始化值。

（2）设计函数输出稀疏矩阵的值。

（3）构造函数进行两个稀疏矩阵相加，输出最终的稀疏矩阵。

（4）构造函数进行两个稀疏矩阵的相乘，输出最终的稀疏矩阵。

（5）构造函数进行稀疏矩阵的转置，并输出结果。

（6）退出系统。

1.算法概述：首先用两个结构体来定义十字链表元素：typedef struct OLNode{int i,j;int e;struct OLNode *right,*down;}OLNode,*OLink;OLNode结构为链表结点，i,j,e分别表示稀疏矩阵中元素的行，列和值。

typedef struct {int mu,nu,tu; //行数mu，列数nu，非零元素的个数tuOLink *rhead,*chead;}CrossList;CrossList结构用于连接起各个结点，mu,nu,tu分别表示整个矩阵的行数列数和非零元素的个数。

整个程序包含CreateSMatix_OL（用于创建十字链表），SMatrix_ADD（十字链表相加），ShowMAtrix(十字链表显示)，MultSMatrix_OL（十字链表相乘），TurnSMatrix_OL（十字链表转置），DestroySMatrix_OL（十字链表销毁）六个函数。

CreateSMatix_OL的功能如下：首先输入稀疏矩阵的行数，列数，非零元素的个数，为*rhead和*chead分配内存空间，并将十字链表中节点初始化为NULL。

然后依次输入非零元素的行，列，值，以0 0 0为结尾结束链表的连接和while循环。

SMatrix_ADD 的功能如下：在初始化稀疏矩阵后选择十字链表相加会提示输入另一个稀疏矩阵，连接结束后SMatrix_ADD 函数以循环的方式比较非零元素是否为同一行列，如果是则两值相加，如果不是则把第二个元素加入链表中。

《数据结构课程设计》稀疏矩阵实验报告

目录一、概述 (1)二、系统分析 (1)三、概要设计 (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. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。

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

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

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

数据结构--稀疏矩阵课程设计

安徽理工大学数据结构课程设计说明书题目: 稀疏矩阵的运算院系：计算机科学与工程学院专业班级：计算机10-*班学号： 201030****学生姓名： ******指导教师：2011年 12 月 28 日安徽理工大学课程设计（论文）任务书计算机科学与工程学院学号201030**** 学生姓名***** 专业（班级）计10-* 设计题目稀疏矩阵的运算设计技术参数系统平台：Windows XP开发工具：Microsoft Visual C++ 6.0设计要求(1)存储结构选择三元组存储方式；(2)实现一个稀疏矩阵的转置运算；(3)实现两个稀疏矩阵的加法运算；(4)实现两个稀疏矩阵的减法运算；(5)实现两个稀疏矩阵的乘法运算。

工作量课程设计报告要求不少于3000字。

源程序要求不少于300行工作计划11月9日-11月22日查找相关资料11月23日-11月26日 DOS菜单界面设计11月27日-12月5日设计算法12月6日-12月20日编写代码12月21日-12月28日撰写实验报告参考资料[1]秦锋.数据结构（C语言版）.北京:清华大学出版社,2011[2]温秀梅,丁学均.Visual C++面向对象程序设计.北京:清华大学出版社,2009[3]何钦铭,颜晖.C语言程序设计.北京:高等教育出版社,2008指导教师签字教研室主任签字2011年 11 月 8 日安徽理工大学课程设计（论文）成绩评定表学生姓名：***** 学号：201030**** 专业班级：计10-* 课程设计题目：稀疏矩阵的运算指导教师评语：成绩：指导教师：年月日目录1 问题描述 (1)2 需求分析 (1)3 总体设计 (2)3.1 Matrix结构的定义 (2)3.2 系统流程图 (3)4 详细设计 (4)4.1 “菜单”界面 (4)4.2 建立矩阵 (4)4.3 显示矩阵 (6)4.4 矩阵的转置 (7)4.5 矩阵的加法运算 (8)4.6 矩阵的减法运算 (9)4.7 矩阵的乘法运算 (10)5 程序运行 (11)5.1 输入矩阵 (11)5.2 矩阵转置 (11)5.3 矩阵加法 (12)5.4 矩阵减法 (12)5.5 矩阵乘法 (13)5.6 退出及错误提示 (13)6 总结 (14)参考文献 (15)1 问题描述(1)题目内容：设计稀疏矩阵运算系统实现两个稀疏矩阵的加法、减法、乘法以及转置操作。

数据结构----稀疏矩阵运算器课程设计.

数据结构----稀疏矩阵运算器课程设计目录稀疏矩阵运算器设计 (I)摘要 ................................................................................................................... I I 第一章需求分析 (1)第二章概要设计 (2)第三章设计步骤 (6)3.1 函数说明 (6)3.2 设计步骤 (7)第四章设计理论分析方法 (20)4.1 算法一：矩阵转置 (20)4.2 算法二：矩阵加法 (20)4.3 算法三：矩阵乘法 (21)第五章程序调试 (23)第六章心得体会 (25)参考文献 (26)第一章需求分析1．稀疏矩阵是指那些多数元素为零的矩阵。

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

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

2．以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现矩阵转置，求逆，实现两个矩阵相加、相减和相乘的运算。

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

3．演示程序以用户和计算机的对话方式执行，数组的建立方式为边输入边建立。

4．由题目要求可知：首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。

5．程序可以对三元组的输入顺序不加以限制；根据对矩阵的行列，三元组作直接插入排序，从而进行运算时,不会产生错误。

6．在用三元组表示稀疏矩阵时，相加、乘积和相减所得结果矩阵应该另生成；矩阵求逆时，为了算法方便，使用二维数组存放。

7．程序在VC6.0环境下设计。

程序执行的命令为：1.稀疏矩阵转置; 2.稀疏矩阵加法; ;3. 稀疏矩阵乘法; 4.退出的工作。

第二章概要设计1．抽象数据类型稀疏矩阵的定义如下：ADT SparseMatrix{数据对象：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}基本操作：create(TSMatrix &TM)操作结果：创建稀疏矩阵矩阵TMLocateELem(TSMatrix M,int i,int j,int e)初始条件：稀疏矩阵M存在操作结果：稀疏矩阵中是否存在非零元素A[i][j]，若存在返回edisp(TSMatrix TM)初始条件：稀疏矩阵TM存在操作结果：通常形式输出稀疏矩阵InsertSortMatrix(TSMatrix &TM)初始条件：稀疏矩阵TM存在操作结果：根据对矩阵的行列，三元组TM作直接插入排序TransposeSMatrix(TSMatrix M,TSMatrix &T)初始条件：稀疏矩阵M和T存在操作结果：求稀疏矩阵M转置的稀疏矩阵TAddTSM(TSMatrix A,TSMatrix B,TSMatrix &C)初始条件：稀疏矩阵A，B和C存在操作结果：稀疏矩阵的加法运算:C=A+BSubTSM(TSMatrix A,TSMatrix B,TSMatrix &C)初始条件：稀疏矩阵A，B和C存在操作结果：稀疏矩阵的减法运算:C=A-BMultSMatrix(TSMatrix A,TSMatrix B,TSMatrix &C)初始条件：稀疏矩阵A，B和C存在操作结果：稀疏矩阵的乘法运算:C=A×BNiMatrix(TSMatrix &TM)初始条件：稀疏矩阵TM存在操作结果：稀疏矩阵求逆}ADT SparseMatrix;2. 主程序：void main( ){初始化；do {接受命令；选择处理命令；}while(命令！=“退出”) }3. 本程序有四个模块，调用关系如下：图2.1 4 本程序的流程图图2.2第三章设计步骤3.1函数说明稀疏矩阵的三元组顺序表存储表示：typedef struct // 定义三元组的元素{int i,j;int v;}Triple;class tripletable{ //设计类来描述稀疏矩阵及其操作public:aaa *pdata;triple data[maxsize];int rpos[maxsize]; tripletable();~tripletable();void convert() ;void add( );void multi ( );private:int m ;int n ;int t ;int a ;};主要函数：tripletable();~tripletable();void convert( ) ;void add( );void multi ( );void main( );3.2设计步骤：设计一个矩阵类实现矩阵的运算：class tripletable(包含矩阵的各种运算函数)。

数据结构课程设计--基本稀疏矩阵运算的运算器

数据结构课程设计--基本稀疏矩阵运算的运算器数据结构课程设计五班级：06计本（1）姓名：魏建平学号：20060724035题目：严蔚敏习题实习4第1个：实现一个能进行基本稀疏矩阵运算的运算器一、需求分析1、本程序实现一个基本稀疏矩阵的简单运算，包括加、减、乘。

2、执行操作前应先创造要进行运算的两个矩阵，然后再选择进行相应的操作。

3、以三元组顺序表表示稀疏矩阵，实现二个矩阵相加，相减，相乘的运算；稀疏矩阵的输入形式为三元组表示，运算结果则为通常的阵列形式列出！4、首先输入矩阵的行数和列数，并判别给出的两个矩阵和行、列数对于所要求作的运算是否相匹配。

可设矩阵的行数和列数均不超过20；5、程序先给出了菜单项，用户只需按照菜单提示进行相应的操作就行了。

6、测试数据：二、概要设计1、抽象数据类型三元组的定义如下：ADT Triple{数据对象：D={ai|ai(-ElemSet,i=1,2,...,n,n>=0};数据关系：R1={<ai-1,ai>| ai-1,ai(- D,i=2,...,n}基本操作：略}2、基于三元组顺序表表示的矩阵操作：（1）创建三元组顺序表表示的矩阵：void createMatrix(TSMatrix &A)（2）初始化矩阵：void initMatrix(TSMatrix &A)（3）相加：void add(TSMatrix A,TSMatrix B,TSMatrix &C)（4）相减：void sub(TSMatrix A,TSMatrix &B,TSMatrix &C)（5）找m行n列元素在A中顺序表中的位置：int search(TSMatrix A,int m,int n) （6）相乘；void mult(TSMatrix A,TSMatrix B,TSMatrix &C)（7）输入以阵列形式表示的矩阵：void print(TSMatrix A)3、主程序Void main(){While(true){调用相应函数执行相应操作；输出操作结果；}}4、本程序只有两个模块，调用关系简单：三、详细设计1、三元组结构描述：#define MAXSIZE 20 using namespace std;typedef struct{int row;int col;int e;}Triple;typedef struct{Triple date[MAXSIZE];int m,n,len;}TSMatrix;void initMatrix(TSMatrix &A){A.len=0;A.m=0;A.n=0;for(int i=0;i<MAXSIZE;i++){A.date[i].col=0;A.date[i].e=0;A.date[i].row=0;}}2、各种操作函数源代码：void createMatrix(TSMatrix &A){initMatrix(A);cout<<"创建矩阵:";cout<<"请输入矩阵的行列值及非0元素个数\n";cin>>A.m>>A.n>>A.len;for(int i=0;i<A.len;i++){cout<<"请输入第"<<i<<"个非0元素对应的行、列、值:";cin>>A.date[i].row;cin>>A.date[i].col;cin>>A.date[i].e;}}void add(TSMatrix A,TSMatrix B,TSMatrix &C)//相加{if(A.m==B.m&&A.n==B.n){int i=0,j=0;int k=0;C.m=A.m;C.n=A.n;while( i<A.len||j<B.len){if(i==A.len&&j<B.len){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(i<A.len&&j==B.len){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}else{if(A.date[i].row>B.date[j].row){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(A.date[i].row<B.date[j].row) {C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}else{if(A.date[i].col==B.date[j].col) {if(A.date[i].e+B.date[j].e!=0){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e+B.date[j].e;C.len++;}i++;j++;}else if(A.date[i].col>B.date[j].col){C.date[k].col=B.date[j].col;C.date[k].row=B.date[j].row;C.date[k++].e=B.date[j].e;C.len++;j++;}else if(A.date[i].col<B.date[j].col){C.date[k].col=A.date[i].col;C.date[k].row=A.date[i].row;C.date[k++].e=A.date[i].e;C.len++;i++;}}}}}else{cout<<"不能相加！";}}void sub(TSMatrix A,TSMatrix &B,TSMatrix &C)//相减{for(int k=0;k<B.len;k++){B.date[k].e=-B.date[k].e;}if(A.m==B.m&&A.n==B.n){add(A,B,C);}elsecout<<"不能相减！";for( k=0;k<B.len;k++){B.date[k].e=-B.date[k].e;}}int search(TSMatrix A,int m,int n){int flag=-1;for(int i=0;i<MAXSIZE;i++){if(A.date[i].row==m&&A.date[i].col==n) {flag=i;break;}}return flag;}void mult(TSMatrix A,TSMatrix B,TSMatrix &C)//相乘{int i=0,j=0;if(A.n==B.m){C.m=A.m;C.n=B.n;for(i=0;i<A.len;i++){for(j=0;j<B.len;j++){if(A.date[i].col==B.date[j].row) {intflag=search(C,A.date[i].row,B.date[j].col);if(flag==-1){C.date[C.len].col=B.date[j].col;C.date[C.len].row=A.date[i].row;C.date[C.len++].e=A.date[i].e*B.date[j].e;}else{C.date[flag].e=C.date[flag].e+A.date[i].e*B. date[j].e;}}}}}else{cout<<"不能相乘！"<<endl;}}void print(TSMatrix A){int k=0;int i,j;int M[MAXSIZE][MAXSIZE];for(i=0;i<A.m;i++){for(j=0;j<A.n;j++){M[i][j]=0;}}while(k<A.len){M[A.date[k].row-1][A.date[k].col-1]=A.dat e[k].e;k++;}for(i=0;i<A.m;i++){cout<<"| ";for(j=0;j<A.n;j++){cout<<M[i][j]<<" ";}cout<<"|"<<endl;}}void showtip(){cout<<"------------请选择要执行的操作--------"<<endl;cout<<endl;cout<<" 0---创建矩阵"<<endl;cout<<" 1---A+B"<<endl; cout<<" 2---A-B"<<endl; cout<<" 3---A*B"<<endl; cout<<" 4---退出"<<endl; cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;}3、主函数：void main(){TSMatrix A,B,C;initMatrix(A);initMatrix(B);initMatrix(C);showtip();int i;cin>>i;while(true){switch(i){case 0:system("cls");cout<<"创建矩阵A："<<endl;createMatrix(A);c out<<"创建矩阵B："<<endl;c reateMatrix(B);showtip();break;case 1:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl; }else{initMatrix(C);add(A,B,C);if(A.m==B.m&&A.n==B.n) {cout<<"加的结果；"<<endl; print(A);cout<<"+"<<endl;;print(B);cout<<"="<<endl;print(C);}}showtip();break;case 2:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl; }else{initMatrix(C);sub(A,B,C);cout<<"减的结果；"<<endl; print(A);cout<<"+"<<endl;;print(B);cout<<"="<<endl;print(C);}showtip();break;case 3:system("cls");if(A.m==0||B.m==0){cout<<"未建矩阵"<<endl;}else{initMatrix(C);mult(A,B,C);if(A.n==B.m){cout<<"乘后的结果；"<<endl;print(A);c out<<"*"<<endl;print(B);c out<<"="<<endl;p rint(C);}}showtip();break;case 4:exit(0);break;}cin>>i;}}四、调试分析1、由于本程序涉及的函数比较多，所以开始时在函数调用上出现了混乱，把自己都给搞糊涂了，后来经仔细排查，最终发现了错误。

课程设计报告(一元稀疏矩阵计算器)

目录一、课程题目 (3)二、设计目的 (3)三、需求分析 (3)四、总体设计 (3)五、详细设计 (2)六、实现部分 (3)七、程序测试 (3)八、设计总结 (12)一、课程题目一元稀疏多项式计算器二、设计目的掌握稀疏矩阵的相关运算。

掌握广义表的操作。

三、需求分析一元稀疏多项式简单计算器的基本功能是：输入并建立多项式；输出多项式,输出形式为整数序列：n,c1,e1,,c2,e2 ……cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。

多项式a和b相加,建立多项式a+b多项式a和b相减,建立多项式a-b四、总体设计创建两个类，把一个作为另一个的友元类！两个类分别是listnode和polynomial！创建一个链表，包括指数，次数以及下一个结点信息，然后利用冒泡排序法进行排序，排完之后输出多项式！最后一个环节就是进行多项式的最原始运算，即加减运算！其中运用的内容包括链表知识，冒泡排序的知识！五、详细设计类listnode中包含friend class polynomial、double coef、int exp、listnode *next！类polynomial包含poly(); void printpoly();void bubblesort();polynomial operator+(polynomial &p1); polynomial operator-(polynomial &p1);在这个程序设计中，为了实现多项式的运算必须首先创建两个多项式，存储多项式的存储结构是链表，其结构如下：else if(p->exp<q->exp){double m;int n;m=p->coef;p->coef=q->coef;q->coef=m;n=p->exp;p->exp=q->exp;q->exp=n;s=q;q=q->next;｝再就是实现多项式的加减法运算，在加减法运算中为了实现处理，设p、q分别指向单链表的两个多项式，比较p、q结点的指数项，由此得到下列运算规则：①若p->exp<q->exp，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。

稀疏矩阵运算器

} 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"); }

数据结构----稀疏矩阵运算器课程设计报告书

稀疏矩阵运算器实验报告

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

稀疏矩阵运算器-数据结构课程设计

三元组顺序表稀疏矩阵课程设计报告(不完整)

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

数据结构 稀疏矩阵运算器课程设计

稀疏矩阵(算法与数据结构课程设计)

数据结构课程设计稀疏矩阵

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

数据结构——稀疏矩阵运算器

《数据结构 课程设计》稀疏矩阵实验报告

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

《数据结构 课程设计》稀疏矩阵实验报告

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

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

数据结构--稀疏矩阵课程设计

数据结构----稀疏矩阵运算器课程设计.

数据结构课程设计--基本稀疏矩阵运算的运算器

课程设计报告(一元稀疏矩阵计算器)

稀疏矩阵运算器

数据结构稀疏矩阵运算器课程设计

《数据结构课程设计》稀疏矩阵实验报告

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

《数据结构课程设计》稀疏矩阵实验报告