稀疏矩阵的运算课程设计
课程设计 稀疏矩阵应用
数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 8404181题目: 稀疏矩阵应用年级/专业/班:学生姓名:学号:开始时间:2011 年06 月13日完成时间:2011 年06月21 日课程设计成绩：学习态度及平时成绩（30）技术水平与实际能力（20）创新（5）说明书撰写质量（45）总分（100）指导教师签名：年月日目录1 引言 (1)1.1问题的提出 (1)1.2国内外研究的现状 (1)1.3任务与分析 (1)2 程序的主要功能 (1)2.1三元组的转置 (1)2.2三元组的加法 (1)2.3三元组的减法 (1)2.4三元组的乘法 (2)2.5十字链表的转置 (2)2.6十字链表的加法 (2)2.7十字链表的减法 (2)2.8十字链表的乘法 (2)3程序运行平台 (3)4总体设计 (3)5程序类的说明 (4)6 模块分析 (5)6.1三元组的转置 (5)6.2三元组减法 (6)6.3三元组的减法 (9)6.4三元组的乘法 (12)6.5十字链表的转置 (14)6.6十字链表的加法 (15)6.7十字链表的减法 (18)6.8十字链表的乘法 (22)7 系统测试 (25)7.1三元组的转置 (25)7.2三元组的加法 (26)7.3三元组的减法 (26)7.4三元组的乘法 (27)7.5十字链表的转置 (27)7.6十字链表的加法 (28)7.7十字链表的减法 (28)7.8十字链表的乘法 (29)7.9总结 (29)8结论 (29)参考文献 (29)摘要随着计算机的普及，一句话引出题目…（小四楷体_GB2312），分析了三元组和十字链表的存储和各种运算的实现，利用C语言编程实现了稀疏矩阵的运算系统，该系统具有三元组十字链表存储下的稀疏矩阵转置、加法、减法、乘法的功能。
关键词：稀疏矩阵;计算机; 运算器1 引言1.1 问题的提出矩阵是很多科学与工程计算问题中研究的数学对象。
稀疏矩阵课程设计
数据结构课程设计设计说明书稀疏矩阵相关操作的实现学生姓名学号班级成绩指导教师数学与计算机科学学院2014年1月5日课程设计任务书2013—2014学年第1学期专业：学号：姓名：课程设计名称：课程设计Ⅰ设计题目：稀疏矩阵相关操作的实现完成期限：自年月日至年月日共周设计内容：若矩阵非零元较零元少，且分布没有一定规律，则称之为稀疏矩阵。
运用C、JA V A、VC++编程工具，编程实现稀疏矩阵的相关操作。
要求:1）阐述设计思想，画出流程图；2）主要功能：(1)输入相关数据建立稀疏矩阵；(2)实现稀疏矩阵转置；(3)实现两个稀疏矩阵相乘。
3）从时间、空间对算法分析；4）较好的界面设计；5）编写课程设计报告。
以上要求中第一个阶段的任务完成后，先将设计说明书的草稿交指导老师面审，审查合格后方可进入后续阶段的工作。
设计工作结束后，经指导老师验收合格后将设计说明书打印装订，并进行答辩。
指导教师（签字）：教研室负责人：批准日期：年月日课程设计评阅摘要本文以VC++作为软件开发环境，三元组表作为存储结构，设计与实现了稀疏矩阵运算器。
该计算器实现简单稀疏矩阵的乘法、转置、相乘等主要功能。
计算器。
界面清晰，操作简单，易于为用户所接受。
关键词：VC++；三元表；乘法；转置目录一、课题描述 (1)二、问题描述 (2)2.1 问题指出 (2)2.2 问题需求 (2)2.3 测试数据 (2)2.4 问题阐述 (2)三、算法描述 (3)3.1 定义结构 (3)3.2 实现功能 (3)四、算法流程图 (5)五、算法实现 (6)5.1 菜单模块 (6)5.2 建立矩阵模块 (7)5.3 输出矩阵 (8)5.4 转置矩阵 (9)5.5 矩阵相乘 (9)六、运行程序 (12)6.1 菜单界面 (12)6.2 建立矩阵 (12)6.3 矩阵转置 (13)6.4 矩阵相乘 (13)七、时间及空间复杂度分析 (15)八、总结 (16)参考文献 (17)一、课题描述稀疏矩阵是指那些多数元素为零的矩阵。
数据结构+课程设计+稀疏矩阵的操作(计算机学院)
计算机科学技术学院学生课程设计（论文）题目：学生姓名：学号：所在院(系)：专业：班级：指导教师：职称：年月日计算机科学技术学院本科学生课程设计任务书注：任务书由指导教师填写。
课程设计（论文）指导教师成绩评定表稀疏矩阵的操作1.课程设计的目的本课程设计是为了配合《数据结构》课程的开设，通过设计一完整的程序，使学生掌握数据结构的应用、算法的编写、类C语言的算法转换成C程序并用TC上机调试的基本方法。
利用三元组实现稀疏矩阵的有关算法。
2．问题描述2.1稀疏矩阵采用三元组表示，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C。
2.2求出A的转置矩阵D，输出D。
3. 基本要求稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。
稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则通常以阵列形式列出。
4.结构设计4.1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。
4.2.稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则通常以阵列形式列出。
4.3.首先应输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。
可设矩阵的行数和列数均不超过20。
4.4.程序可以对三元组的输入顺序加以限制，例如，按行优先。
注意研究教材的算法，以便提高计算效率。
5.在用三元组表示稀疏矩阵时，相加或相减所得结果矩阵应该另生成，乘积矩阵也可用二维数组存放5.算法思想5.1．主函数设置循环和选择语句进行运算循环和选择，进行稀疏矩阵的加法，减法，乘法，转置和是否继续运算5个分支开关进行运算选择。
5.2．设置函数分别实现稀疏矩阵的输入，输出，加法，减法，乘法。
5.3．在数组结构体中设置存放每行第一个非零元在其数组存储结构单元的位置的存储单元，若该行无非零元，则存为06.模块划分6.1typedef struct存放各行第一个非零元在存储数组中的位置，若该行无非零元，则其rpos[]值为零6.2 createsmatrix(rlsmatrix *M) 矩阵输入函数，输入各行非零元及其在矩阵中的行列数6.3 FasttransposeRLSMatrix(RLSMatrix M,RLSMatrix *Q) 矩阵快速转置6.4 HeRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q) 矩阵求和6.5 ChaRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q) 矩阵求差6.6 JiRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q) 矩阵求积7.算法实现7.1首先定义非零元个数的最大值和存放各行第一个非零元在存储数组中的位置#include<stdio.h>#define MAXSIZE 100 /* 非零元个数的最大值*/typedef struct triple{int i,j; /* 行下标,列下标*/int e; /* 非零元素值*/}triple;typedef struct tsmatrix{triple data[MAXSIZE+1]; /* 非零元三元组表,data[0]未用*/int mu,nu,tu; /* 矩阵的行数、列数和非零元个数*//* 各列第一个非零元的位置表rpos[0]未用*/}rlsmatrix;7.2创建稀疏矩阵矩阵的行数，列数，和非零元素的个数并按行序顺序输入第%d 个非零元素所在的行(1～%d),列(1～%d),元素值。
数据结构实验报告三稀疏矩阵的运算
数据结构实验报告三稀疏矩阵的运算实验课程名称数据结构课程设计专业班级学⽣姓名学号指导教师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）。
数据结构 稀疏矩阵运算器课程设计
数据结构----稀疏矩阵运算器课程设计目录稀疏矩阵运算器设计............................................................................................ 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不变储存在新的三元组中，不等的则分别储存在此新三元组中。
稀疏矩阵的运算(完美版)
专业课程设计I报告（2011 / 2012 学年第二学期）题目稀疏矩阵的转换专业软件工程学生姓名张鹏宇班级学号 09003018指导教师张卫丰指导单位计算机学院软件工程系日期 2012年6月18号指导教师成绩评定表附件：稀疏矩阵的转换一、课题内容和要求1．问题描述设计程序用十字链表实现稀疏矩阵的加、减、乘、转置。
2．需求分析（1）设计函数建立稀疏矩阵，初始化值。
（2）设计函数输出稀疏矩阵的值。
（3）构造函数进行两个稀疏矩阵相加，输出最终的稀疏矩阵。
（4）构造函数进行两个稀疏矩阵相减，输出最终的稀疏矩阵。
（5）构造函数进行两个稀疏矩阵的相乘，输出最终的稀疏矩阵。
（6）构造函数进行稀疏矩阵的转置，并输出结果。
（7）退出系统。
二、设计思路分析（1）设计函数建立稀疏矩阵，初始化值。
（2）设计函数输出稀疏矩阵的值。
（3）构造函数进行两个稀疏矩阵相加，输出最终的稀疏矩阵。
（4）构造函数进行两个稀疏矩阵相减，输出最终的稀疏矩阵。
（5）构造函数进行两个稀疏矩阵的相乘，输出最终的稀疏矩阵。
（6）构造函数进行稀疏矩阵的转置，并输出结果。
（7）退出系统。
三、概要设计为了实现以上功能，可以从3个方面着手设计。
1．主界面设计为了实现对稀疏矩阵的多种算法功能的管理，首先设计一个含有多个菜单项的主控菜单子程序以链接系统的各项子功能，方便用户交互式使用本系统。
本系统主控菜单运行界面如图所示。
2．存储结构设计本系统采用单链表结构存储稀疏矩阵的具体信息。
其中：全部结点的信息用头结点为指针数组的单链表存储。
3．系统功能设计本系统除了要完成稀疏矩阵的初始化功能外还设置了4个子功能菜单。
稀疏矩阵的初始化由函数i typedef int ElemType 实现。
建立稀疏矩阵用void Creat()实现，依据读入的行数和列数以及非零元素的个数，分别设定每个非零元素的信息。
4个子功能的设计描述如下。
（1）稀疏矩阵的加法：此功能由函数void Xiangjia( )实现，当用户选择该功能，系统即提示用户初始化要进行加法的两个矩阵的信息。
数据结构课程设计稀疏矩阵
稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。
在程序设计中，考虑到方法的难易程度，采用了先用三元组实现稀疏矩阵的输入，输出，及其转置，相加，相乘操作的方法，再在十字链表下实现。
程序通过调试运行，结果与预期一样，初步实现了设计目标。
关键词程序设计；稀疏矩阵；三元组；十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。
稀疏矩阵采用三元组和十字链表表示，并在两种不同的存储结构下，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；求出A的转置矩阵D，输出D；求两个稀疏矩阵A和B的相乘矩阵E，并输出E。
1.2课程设计性质数据结构课程设计是重要地实践性教学环节。
在进行了程序设计语言课和《数据结构》课程教学的基础上，设计实现相关的数据结构经典问题，有助于加深对数据结构课程的认识。
本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现，包括在三元组和十字链表下存储稀疏矩阵，并对输入的稀疏矩阵进行转置，相加，相乘等操作，最后把运算结果输出。
此课程设计要求对数组存储结构和链表存储结构非常熟悉，并能熟练使用它们。
1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上，掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置，相加，相乘等基本操作，并用不同的方法输出结果，进一步掌握设计、实现较大系统的完整过程，包括系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及操作方法，为进一步的应用开发打好基础。
2需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化，包括在三元组结构下和十字链表结构下。
首先要定义两种不同的结构体类型，在创建稀疏矩阵时，需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵，在输入出现错误时，能够对错误进行判别处理，初始化稀疏矩阵都为空值，特别注意在十字链表下，对变量进行动态的地址分配。
稀疏矩阵的操作课程设计
摘要随着科学技术的飞速发展，人类的生活工作方式发生了很大的改变，工作效率随着高科技的加入有了质的提高，特别是信息技术和网络技术的迅速发展和广泛应用，对社会的政治，经济，军事，文化等领域产生越来越深刻的影响。
现代生活各个方面都离不开计算机技术，而C是国际上广泛流行的通用程设语言，在计算机的研究和应用中以展现强大的生命力。
C功能强大，使用灵活，既具有高级语言的特点，又具有低级语言的些特点;它既可用于编写系统软件又可用于编写应用软件。
本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。
在程序设计中，采用了先用三元组实现稀疏矩阵的输入，输出，及其转置，相加，相乘操作的方法。
程序通过调试运行，结果与预期一样，初步实现了设计目标。
关键词：稀疏矩阵，三元组，链表I目录摘要 (I)1 课程设计的目的和意义 (1)2 需求分析 (1)2.1需求概述 (1)2.2 需求环境 (2)3 系统功能设计及数据结构设计 (2)3.1模块设计 (2)3.2系统子程序及功能设计 (2)4 算法设计、数据流图及程序结构框图 (2)4.1 程序功能模块 (2)4.2 程序流程图 (4)5 程序原代码及其说明 (5)6 程序测试及运行结果说明 (10)7 总结 (14)主要参考资料 (14)1 课程设计的目的和意义通过本课程设计教学所要达到的目的是：培养学生用学到的书本知识解决实际问题的能力；培养实际工作所需要的动手能力；培养学生以科学理论和工程上能力的技术，规范地开发大型、复杂、高质量的应用软件和系统软件具有关键性作用；通过课程设计的实践，学生可以在程序设计方法、上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
2 需求分析2.1需求概述1. 问题描述设计程序用十字链表实现稀疏矩阵的加、乘、转置。
基本功能要求：（1） 稀疏矩阵采用三元组表示，求两个具有相同行列数的稀疏矩阵A 和B的相加矩阵C ，并输出C 。
数据结构与课程设计 稀疏矩阵
实验课程名称数据结构与课程设计专业班级 10级计科（2）班学生姓名赵腾松学号 10410902044 指导教师冯韵2012 至 2013学年第 1 学期第 4 至 5 周目录1 概述 ...............................................................................................................- 1 -1 系统分析 .............................................................................. 错误！未定义书签。
2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值........................ - 1 -2.2造函数并输出最终稀疏矩阵 (1)3 概要设计 (1)3.1存储结构设计 (1)3.2系统功能设计 (1)4 详细设计 ........................................................................................................- 2 -4.1 稀疏矩阵的存储 ................................................................................... - 2 -4.2 稀疏矩阵的加法 (2)5 程序代码 ........................................................................................................- 4 -6 运行与测试.....................................................................................................-7 -7 总结与心得 (7)8 参考文献 (7)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 函数以循环的方式比较非零元素是否为同一行列，如果是则两值相加，如果不是则把第二个元素加入链表中。
课程设计报告—稀疏矩阵的完全链表表示及其运算
合肥学院计算机科学与技术系课程设计报告2014 ～2015 学年第2 学期课程数据结构与算法稀疏矩阵的完全链表表示及其运算课程设计名称学生姓名学号专业班级13软件工程（2）班指导教师陈老师20 15 年1 月稀疏矩阵的完全链表表示及其运算【问题描述】稀疏矩阵的每个结点包含down，right，row，col和value五个域。
用单独一个结点表示一个非零项，并将所有结点连接在一起，形成两个循环链表。
使得第一个表即行表，把所有结点按照行序（同一行内按列序）用right域链接起来。
使得第二个表即列表，把所有结点按照列序（同一列内按行序）用down链接起来。
这两个表共用一个头结点。
另外，增加一个包含矩阵维数的结点。
稀疏矩阵的这种存储表示称为完全链表表式。
实现一个完全链表系统进行稀疏矩阵运算，并分析下列操作函数的计算时间和额外存储空间的开销。
【设计目的】认识和掌握稀疏矩阵的完全链表表示；能够建立并运用这种存储结构【基本要求】建立一个用户友好、菜单式系统进行下列操作，并使用合当的测试数据测试该系统。
读取一个稀疏矩阵建立其完全链表表示输出一个稀疏矩阵的内容删除一个稀疏矩阵两个稀疏矩阵相加两个稀疏矩阵相减两个稀疏矩阵相乘稀疏矩阵的转置【实现提示]链表上的操作。
二、数据结构的选择和概要设计（一）、问题分析1、功能要求：根据用户输入的矩阵，实现稀疏矩阵的求和运算，并输出结果。
2、输入要求：矩阵的数据在程序运行的时候由用户提供，先由用户输入稀疏矩阵的行数、列数和非零元个数。
再根据非零元个数，输入这些非零元，还需要用户为这些非零元输入行、列和非零元的值。
这样，一个稀疏矩阵就输入完成。
3、用单链表存储非零元素的结点信息，并且将之用矩阵的形式打印出来（二）、概要设计1、结构体的定义typedef int ElemType;struct OLNode{int i,j; //非零元所在行、列ElemType e;//非零元值OLNode *right,*down;};typedef OLNode *OLink;struct CrossList{OLink *rhead,*chead;//行、列表头的头节点int mu,nu,tu;//矩阵的行、列和非零元个数};2、存储结构选择采用十字链表存储稀疏矩阵，它是稀疏矩阵链式表示的一种较好的表示方法。
稀疏矩阵的转置课程设计
稀疏矩阵的转置课程设计一、课程目标知识目标：1. 理解稀疏矩阵的概念及特点；2. 掌握稀疏矩阵转置的数学定义和性质；3. 学会使用压缩存储方法对稀疏矩阵进行转置操作；4. 能够运用转置后的稀疏矩阵解决实际问题。
技能目标：1. 培养学生运用数学软件或编程语言处理稀疏矩阵转置问题的能力；2. 提高学生分析问题、解决问题的能力；3. 培养学生的逻辑思维和抽象思维能力。
情感态度价值观目标：1. 培养学生对线性代数学科的兴趣和热情；2. 培养学生严谨、求实的科学态度；3. 增强学生的团队合作意识和协作能力；4. 引导学生认识到数学在自然科学和工程技术领域的重要作用。
本课程针对高年级学生，结合稀疏矩阵的转置这一章节内容，注重理论与实践相结合。
在教学过程中，充分考虑学生的认知特点，采用启发式教学，引导学生自主探究和合作学习。
通过本课程的学习，使学生不仅掌握稀疏矩阵转置的相关知识，而且提高解决实际问题的能力，培养良好的情感态度价值观。
二、教学内容1. 稀疏矩阵的基本概念与性质- 稀疏矩阵的定义- 稀疏矩阵的存储方法：压缩存储- 稀疏矩阵的运算规则2. 稀疏矩阵转置的数学定义- 转置矩阵的定义及性质- 稀疏矩阵转置的数学表达式3. 稀疏矩阵转置的算法实现- 顺序转置法- 分块转置法- 矩阵压缩存储下的转置方法4. 稀疏矩阵转置的应用实例- 图像处理中的稀疏矩阵转置- 工程问题中的稀疏矩阵转置应用5. 教学案例分析及讨论- 结合实际案例，分析稀疏矩阵转置的必要性- 讨论不同转置算法的优缺点及适用场景本教学内容依据课程目标，结合教材章节，按照由浅入深、循序渐进的原则进行安排。
在教学过程中，注重理论与实践相结合，强调算法实现与应用。
通过本章节的学习，使学生全面掌握稀疏矩阵转置的相关知识，提高解决实际问题的能力。
三、教学方法1. 讲授法- 对于稀疏矩阵的基本概念、性质及转置的数学定义等理论知识，采用讲授法进行教学，使学生系统掌握相关知识。
数据结构--稀疏矩阵课程设计
安徽理工大学数据结构课程设计说明书题目: 稀疏矩阵的运算院系：计算机科学与工程学院专业班级：计算机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、由于本程序涉及的函数比较多，所以开始时在函数调用上出现了混乱，把自己都给搞糊涂了，后来经仔细排查，最终发现了错误。
稀疏矩阵的运算(完美版)
专业课程设计I报告（2011 / 2012 学年第二学期）题目稀疏矩阵的转换专业软件工程学生姓名张鹏宇班级学号09003018指导教师张卫丰指导单位计算机学院软件工程系日期2012年6月18号指导教师成绩评定表附件：稀疏矩阵的转换一、课题内容和要求1．问题描述设计程序用十字链表实现稀疏矩阵的加、减、乘、转置。
2．需求分析（1）设计函数建立稀疏矩阵，初始化值。
（2）设计函数输出稀疏矩阵的值。
（3）构造函数进行两个稀疏矩阵相加，输出最终的稀疏矩阵。
（4）构造函数进行两个稀疏矩阵相减，输出最终的稀疏矩阵。
（5）构造函数进行两个稀疏矩阵的相乘，输出最终的稀疏矩阵。
（6）构造函数进行稀疏矩阵的转置，并输出结果。
（7）退出系统。
二、设计思路分析（1）设计函数建立稀疏矩阵，初始化值。
（2）设计函数输出稀疏矩阵的值。
（3）构造函数进行两个稀疏矩阵相加，输出最终的稀疏矩阵。
（4）构造函数进行两个稀疏矩阵相减，输出最终的稀疏矩阵。
（5）构造函数进行两个稀疏矩阵的相乘，输出最终的稀疏矩阵。
（6）构造函数进行稀疏矩阵的转置，并输出结果。
（7）退出系统。
三、概要设计为了实现以上功能，可以从3个方面着手设计。
1．主界面设计为了实现对稀疏矩阵的多种算法功能的管理，首先设计一个含有多个菜单项的主控菜单子程序以链接系统的各项子功能，方便用户交互式使用本系统。
本系统主控菜单运行界面如图所示。
2．存储结构设计本系统采用单链表结构存储稀疏矩阵的具体信息。
其中：全部结点的信息用头结点为指针数组的单链表存储。
3．系统功能设计本系统除了要完成稀疏矩阵的初始化功能外还设置了4个子功能菜单。
稀疏矩阵的初始化由函数i typedef int ElemType 实现。
建立稀疏矩阵用void Creat()实现，依据读入的行数和列数以及非零元素的个数，分别设定每个非零元素的信息。
4个子功能的设计描述如下。
（1）稀疏矩阵的加法：此功能由函数void Xiangjia( )实现，当用户选择该功能，系统即提示用户初始化要进行加法的两个矩阵的信息。
课程设计稀疏矩阵计算c语言
课程设计稀疏矩阵计算c语言一、教学目标本课程的教学目标是使学生掌握稀疏矩阵在C语言中的计算方法，培养学生运用C语言进行编程和解决问题的能力。
具体目标如下：1.知识目标：a.理解稀疏矩阵的基本概念及其在实际应用中的重要性。
b.掌握C语言中稀疏矩阵的存储方法和基本操作。
c.学习并理解稀疏矩阵的计算算法及其原理。
2.技能目标：a.能够使用C语言实现稀疏矩阵的创建、显示和基本运算。
b.能够运用稀疏矩阵计算方法解决实际问题。
c.培养学生的编程能力，提升其逻辑思维和问题解决能力。
3.情感态度价值观目标：a.培养学生对计算机科学和编程的兴趣，增强其学习动力。
b.培养学生团队合作精神，鼓励学生在解决问题时互相帮助、共同进步。
c.通过实际应用，使学生认识到稀疏矩阵计算在科学研究和工程领域的重要性，培养其责任感。
二、教学内容本课程的教学内容主要包括以下几个部分：1.稀疏矩阵概念及相关定义。
2.C语言中稀疏矩阵的存储方法：压缩存储技术。
3.稀疏矩阵的基本运算：创建、显示、加法、乘法等。
4.稀疏矩阵计算算法介绍：前向填充算法、高斯消元法等。
5.实际案例分析：运用稀疏矩阵计算解决工程和科学研究问题。
三、教学方法为了提高教学效果，本课程将采用多种教学方法相结合的方式进行教学：1.讲授法：用于讲解稀疏矩阵的基本概念、理论和算法。
2.案例分析法：通过分析实际案例，使学生更好地理解稀疏矩阵的计算方法和应用。
3.实验法：安排上机实验，让学生动手实践，巩固所学知识。
4.小组讨论法：鼓励学生分组讨论，培养团队合作精神，提高问题解决能力。
四、教学资源为了支持本课程的教学，我们将准备以下教学资源：1.教材：《C语言程序设计》、《稀疏矩阵计算》等。
2.参考书：提供相关的学术论文和书籍，供学生深入研究。
3.多媒体资料：制作课件、教学视频等，丰富教学手段，提高教学质量。
4.实验设备：提供计算机实验室，让学生能够进行上机实践。
五、教学评估为了全面、客观地评估学生的学习成果，本课程将采取以下评估方式：1.平时表现：通过课堂参与、提问、小组讨论等环节，评估学生的学习态度和积极性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计说明书题目: 稀疏矩阵的运算院系：计算机科学与工程学院专业班级：计算机10-**班学号： 201030****学生姓名： ******指导教师： ******2011年 12 月 28 日安徽理工大学课程设计（论文）任务书计算机科学与工程学院2011年 11 月 8 日安徽理工大学课程设计（论文）成绩评定表目录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 矩阵的乘法运算 (9)5 程序运行 (11)5.1 输入矩阵 (11)5.2 矩阵转置 (11)5.3 矩阵加法 (12)5.4 矩阵减法 (12)5.5 矩阵乘法 (12)5.6 退出及错误提示 (13)6 总结 (13)参考文献 (14)1 问题描述(1)题目内容：设计稀疏矩阵运算系统实现两个稀疏矩阵的加法、减法、乘法以及转置操作。
(2)基本要求：①存储结构选择三元组存储方式；②实现一个稀疏矩阵的转置运算；③实现两个稀疏矩阵的加法运算；④实现两个稀疏矩阵的减法运算；⑤实现两个稀疏矩阵的乘法运算。
(3)设计目的：通过本次课程设计，了解稀疏矩阵的一些基本运算操作，并通过相关的程序代码实现。
2 需求分析经过本次的课程设计，我认为稀疏矩阵运算系统主要实现的功能如下：(1)建立矩阵：只有先建立了矩阵，才能够对矩阵进行运算操作，包括建立矩阵A和矩阵B；(2)转置运算操作：对矩阵A或者矩阵B进行转置运算，输出相应的转置矩阵；(3)四则运算操作：该步骤由两个矩阵同时参与，对其进行加法运算(A+B)、减法运算(A-B)以及乘法运算(A*B和B*A)；(4)退出：当做完矩阵的运算操作之后，就可以点击它退出该界面。
在这次设计中用到了一些变量和函数，例如：void Display(Matrix M)；int Max(int i,int j)；Matrix Zero(Matrix M)等，下面会做进一步详细的介绍。
3 总体设计3.1 Matrix结构的定义struct Matrix{int H; //矩阵的行数int L; //矩阵的列数int fly; //矩阵中的非零元个数int zhi[Maxsize][Maxsize];//非零元值[所在行][所在列] };操作集合：(1)Matrix Enter(Matrix M); //建立矩阵M(2)void Display(Matrix M); //显示矩阵M(3)void Transpose(Matrix M); //M矩阵的转置(4)void Add(Matrix M,Matrix N); //求和运算 A+B(5)void Sub(Matrix M,Matrix N); //求差运算 A-B(5)void Multi(Matrix M,Matrix N); //求积运算 A*B(6)int Max(int i,int j); //求最大值(7)Matrix Zero(Matrix M); //矩阵所有元素赋值为03.2 系统流程图该运算系统的系统流程图如图1所示：图1 系统流程图4 详细设计4.1 “菜单”界面进入稀疏矩阵运算系统后的“菜单”界面如图2所示。
图2 “菜单”界面4.2 建立矩阵矩阵在建立之后才能够进行运算操作，建立矩阵A和矩阵B，调用函数Enter(M)，首先根据所输入的矩阵M的行数H和列数L，建立H*L的矩阵M，并且调用函数Zero(M)将其所有元素均赋值为0；其次再根据所输入矩阵M 的非零元个数fly做循环控制变量，按提示输入非零元所在的行h和列l以及非零元的值，如果输入的行h或者列l大于矩阵M的行H或列L，则提示输入错误；最后将非零元的值保存在矩阵M中的相应位置。
程序如下：Matrix Enter(Matrix M) //建立矩阵{cin>>M.H>>M.L;cout<<"请输入矩阵的非零元个数:";cin>>M.fly;cout<<endl;if(M.fly>(M.H*M.L)){cout<<"非零元个数多于矩阵元素总数,请重新输入!"<<endl;cout<<"请重新输入矩阵的非零元个数:";cin>>M.fly;}M=Zero(M);int h;int l;for(int n=1;n<=M.fly;n++) //输入非零元所在的行、列和值{cout<<"请输入第"<<n<<"个非零元所在的行和列:";cin>>h>>l;if(h>M.H||l>M.L) // 行列输入错误提示{cout<<"行列输入错误,请重新输入:"<<endl;cout<<"请重新输入第"<<n<<"个非零元所在的行和列:";cin>>h>>l;}cin>>M.zhi[h][l];cout<<endl;}return M;}注：该函数中调用的Zero()函数的功能为将矩阵M根据行数H和列数L 把所有的元素赋值为0，代码如下：Matrix Zero(Matrix M)//矩阵所有元素赋值为0{for(int i=1;i<=M.H;i++)for(int j=1;j<=M.L;j++)M.zhi[i][j]=0;return M;}4.3 显示矩阵建立好矩阵以后，为了验证所建立的矩阵是否成功，以及在后期运算时矩阵的显示，设计该函数，能更直观的看到输入以及输出的矩阵，代码如下：void Display(Matrix M) //显示矩阵{int count=0;cout<<"矩阵为:"<<endl;for(int i=1;i<=M.H;i++)for(int j=1;j<=M.L;j++){printf("%-4d",M.zhi[i][j]);count++;if(count==M.L){cout<<endl;count=0;}}cout<<endl;}4.4 矩阵的转置该函数实现的是矩阵A或矩阵B的转置操作，通过对矩阵的行和列进行调换，利用for()循环语句实现对矩阵A或矩阵B的转置，其代码如下：void Transpose(Matrix M) //矩阵转置{C.H=M.L;C.L=M.H;cout<<"原来的";Display(M);for(int i=1;i<=M.L;i++)for(int j=1;j<=M.H;j++){C.zhi[i][j]=M.zhi[j][i];}cout<<"转置后的";Display(C);}4.5 矩阵的加法运算实现两个矩阵之间的加法运算，即A+B，其代码如下：void Add(Matrix M,Matrix N) //A+B{int n1=Max(M.H,N.H);int n2=Max(M.L,N.L);C.H=n1;C.L=n2;C=Zero(C);for(int i=1;i<=n1;i++)for(int j=1;j<=n2;j++){C.zhi[i][j]=M.zhi[i][j]+N.zhi[i][j];}cout<<" A+B 的运算结果";Display(C);}4.6 矩阵的减法运算实现两个矩阵之间的减法运算，即A－B，其代码如下：void Sub(Matrix M,Matrix N) //A-B{int n1=Max(M.H,N.H);int n2=Max(M.L,N.L);C.H=n1;C.L=n2;C=Zero(C);for(int i=1;i<=n1;i++)for(int j=1;j<=n2;j++){C.zhi[i][j]=M.zhi[i][j]-N.zhi[i][j];}cout<<" A-B 的运算结果";Display(C);}4.7 矩阵的乘法运算实现两个矩阵之间的乘法运算，即A*B，如果矩阵A的列数和矩阵B的行数不相同,则无法进行乘法运算，系统会提示错误，其代码如下：void Multi(Matrix M,Matrix N) //A*B{if(M.L!=N.H){cout<<"矩阵A的列数和矩阵B的行数不相同,无法进行乘法运算!\n";}elseif(M.L==N.H){C.H=M.H;C.L=N.L;C=Zero(C);for(int i=1;i<=Maxsize;i++)for(int j=1;j<=Maxsize;j++)for(int k=1;k<=Maxsize;k++){C.zhi[i][j]+=M.zhi[i][k]*N.zhi[k][j];}cout<<"运算结果";Display(C);}}5 程序运行5.1 输入矩阵运行该运算系统，进入“菜单”选项以后，输入“1”，选择“输入矩阵A”，运算结果如图3所示；输入“2”，选择“输入矩阵B”，运算结果如图4所示：图3 输入矩阵A 图4 输入矩阵B5.2 矩阵转置输入矩阵A和矩阵B以后，在“菜单”提示下，输入“3”，进行矩阵A的转置，运算结果如图5所示；输入“4”，进行矩阵B的转置，运算结果如图6所示：图5 矩阵A的转置图6 矩阵B的转置5.3 矩阵加法在“菜单”提示下，输入“5”，进行两个矩阵的加法运算，即A+B，运算结果如图7所示：图7 矩阵加法5.4 矩阵减法在“菜单”提示下，输入“6”，进行两个矩阵的加法运算，即A-B，运算结果如图8所示：图8 矩阵减法5.5 矩阵乘法在“菜单”提示下，输入“7”，进行两个矩阵的第一种乘法运算，即A*B，运算结果如图9所示；输入“8”，进行两个矩阵的第二种乘法运算，即B*A，运算结果如图10所示：图9 矩阵乘法1(A*B) 图10 矩阵乘法2(B*A)5.6 退出及错误提示算法在运行时还有退出及错误提示功能，在“菜单”提示下，输入“0”则退出系统，如图11所示；若输入0－8以外的数字，则会出现错误提示，如图12所示：图11 退出图12 错误提示6 总结通过对数据结构这门课的学习，我了解到：“数据结构”在计算机科学中是一门综合性的专业基础课。