数据结构 稀疏矩阵运算器课程设计
课程设计 稀疏矩阵应用
数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 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 问题的提出矩阵是很多科学与工程计算问题中研究的数学对象。
数据结构+课程设计+稀疏矩阵的操作(计算机学院)
计算机科学技术学院学生课程设计（论文）题目：学生姓名：学号：所在院(系)：专业：班级：指导教师：职称：年月日计算机科学技术学院本科学生课程设计任务书注：任务书由指导教师填写。
课程设计（论文）指导教师成绩评定表稀疏矩阵的操作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）。
4.1稀疏矩阵运算器
稀疏矩阵运算器一．实验目的使读者能深入研究数组的存储表示和实现技术二．实验内容【问题描述】稀疏矩阵是指那些多数元素为零的矩阵，利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
【基本要求】以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。
稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的陈列形式列出。
【实现提示】1、首先应先输入矩阵的行数和列数，并判别给出的两个矩阵的行、列数对于所要求做的运算是否相匹配，可设矩阵的行数和列数不超过20；2、程序可以对三元组的输入顺序加以限制，例如，按行优先。
3、在用三元组表示稀疏矩阵时，相加或相减所得结果矩阵应该另生成，乘积矩阵也可用二维数组存放。
三．实验步骤（可选）#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;#define MAXSIZE 100#define MAXROW 100#define OK 1#define ERROR -1typedef struct{int row; //行数int col; //列数int v; //非零元素值}triplenode;typedef struct{triplenode data[MAXSIZE+1]; //非零元三元组int rowtab[MAXROW+1];//各行第一个非零元的位置表int mu,nu,tu; //矩阵的行数、列数和非零元个数}rtripletable;void creat(rtripletable &A){ //创建稀疏矩阵int k=1,sum=1,loop,p,t;int num[MAXROW+1];cout<<"请输入矩阵的行数和列数:"<<endl;cout<<"行数:";cin>>A.mu;cout<<"列数:";cin>>A.nu;cout<<"非零元素个数:";cin>>A.tu;cout<<"请输入该矩阵的非零元:格式行+列+值.(ps:以输入全零为结束标记!）"<<endl;for(loop=1;loop<=A.tu;loop++){//输入三元组的行数，列数和非零元素值cin>>A.data[loop].row;cin>>A.data[loop].col;cin>>A.data[loop].v;}for(p=1;p<=A.mu;p++) num[p]=0;//A三元组每一列的非零元素个数for(t=1;t<=A.tu;t++) ++num[A.data[t].row];//求A中每一列含非零元个数A.rowtab[1]=1;//求第p列中第一个非零元在A.data中的序号for(t=2;t<=A.mu;t++) A.rowtab[t]=A.rowtab[t-1]+num[t-1];return;}void print(rtripletable A){ //输出稀疏矩阵int result[MAXROW+1][MAXROW+1];//定义一个二维数组int i,j;for(i=1;i<=A.mu;i++)for(j=1;j<=A.nu;j++)result[i][j]=0; //初始化为0for(i=1;i<=A.tu;i++)result[A.data[i].row][A.data[i].col]=A.data[i].v;for(i=1;i<=A.mu;i++){//输出所做运算的结果for(j=1;j<=A.nu;j++)cout<<result[i][j]<<"\t";cout<<endl;}}int addsmatrix(rtripletable M, rtripletable N){//矩阵相加if(M.mu!=N.mu) //行数相等才能相加cout<<"ERROR";rtripletable Q;Q.mu=M.mu;Q.nu=N.nu;int p,q,k;p=1;q=1;k=1;while(p<=M.tu&&q<=N.tu){//两个稀疏矩阵存在if(M.data[p].row==N.data[q].row){//两个稀疏矩阵的行数相等if(M.data[p].col==N.data[q].col){//两个稀疏矩阵的列数相等if(M.data[p].v+N.data[q].v!=0){//两个稀疏矩阵相加的结果不为0Q.data[k].row=M.data[p].row;Q.data[k].col=M.data[p].col;Q.data[k].v=M.data[p].v+N.data[q].v;++k;}++q;++p;}else if(M.data[p].col<N.data[q].col){//第一个稀疏矩阵列数小于第二个稀疏矩阵列数Q.data[k]=M.data[p];//把M中的所有信息都赋给Q++p;++k;}else{ //第一个稀疏矩阵列数大于第二个稀疏矩阵的列数Q.data[k]=N.data[q];++q;++k;}}else if(M.data[p].row<N.data[q].row){ //第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=M.data[p];++p;++k;}else{ //第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=N.data[q];++q;++k;}}while(p<=M.tu){ //只有M并且符合条件Q.data[k]=M.data[p];++p;++k;}while(q<=N.tu){ //只有N并且符合条件Q.data[k]=N.data[q];++q;++k;}Q.tu=k-1;cout<<"矩阵相加结果是:"<<endl;print(Q); //调用print()return OK;}int subsmatrix(rtripletable M, rtripletable N){ //稀疏矩阵相减if(M.mu!=N.mu) //行数相等才能相加cout<<"出错";rtripletable Q;Q.mu=M.mu;Q.nu=N.nu;int p,q,k;p=1;q=1;k=1;while(p<=M.tu&&q<=N.tu){ //两个稀疏矩阵存在if(M.data[p].row==N.data[q].row){ //两个稀疏矩阵的行数相等if(M.data[p].col==N.data[q].col){ //两个稀疏矩阵的列数相等if(M.data[p].v-N.data[q].v!=0){ //两个稀疏矩阵相减的结果不为0Q.data[k].row=M.data[p].row;Q.data[k].col=M.data[p].col;Q.data[k].v=M.data[p].v-N.data[q].v;++k;}++q;++p;}if(M.data[p].col<N.data[q].col){ //第一个稀疏矩阵列数小于第二个稀疏矩阵的列数Q.data[k]=M.data[p];++p;++k;}if(M.data[p].col>N.data[q].col){ //第一个稀疏矩阵列数大于第二个稀疏矩阵的列Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}}if(M.data[p].row<N.data[q].row){//第一个稀疏矩阵行列数小于第二个稀疏矩阵行数Q.data[k]=M.data[p];++p;++k;}if(M.data[p].row>N.data[q].row){//第一个稀疏矩阵行列数大于第二个稀疏矩阵行数Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}}while(p<=M.tu){//只有M并且符合条件Q.data[k]=M.data[p];++p;++k;}while(q<=N.tu){//只有N并且符合条件Q.data[k].row=N.data[q].row;Q.data[k].col=N.data[q].col;Q.data[k].v=-N.data[q].v;++q;++k;}Q.tu=k-1;cout<<"矩阵相减结果为:"<<endl;print(Q); //调用print()return OK;}void multsmatrix(rtripletable M, rtripletable N, rtripletable &Q){//稀疏矩阵相乘int arow,brow;int p,q,tp,t;int ccol;int ctemp[MAXROW+1]; //定义累加器if(M.nu!=N.mu)return;Q.mu=M.mu;Q.nu=N.nu;Q.tu=0; //Q初始化if(M.tu*N.tu!=0){ //Q是非零矩阵for(arow=1;arow<=M.mu;arow++){//处理M的每一行for(p=1;p<=Q.nu;p++) //处理M的每一列ctemp[p]=0; //当前行各元素累加器清零Q.rowtab[arow]=Q.tu+1;if(arow<M.mu) tp=M.rowtab[arow+1];else tp=M.tu+1;for(p=M.rowtab[arow];p<tp;++p){//对当前行中每一个非零元brow=M.data[p].col; //找到对应元N中的行号if(brow<N.nu) t=N.rowtab[brow+1];else t=N.tu+1;for(q=N.rowtab[brow];q<t;++q){ccol=N.data[q].col; //乘积元素在Q中列数ctemp[ccol]+=M.data[p].v*N.data[q].v;}} //求得Q中第crow(=arow)行的非零元for(ccol=1;ccol<=Q.nu;ccol++){//压缩存储该行非零元if(ctemp[ccol]){if(++Q.tu>MAXSIZE)return ;Q.data[Q.tu].row=arow; //行数Q.data[Q.tu].col=ccol; //列数Q.data[Q.tu].v=ctemp[ccol];}}}}//累加非零元素值cout<<"乘法结果为:"<<endl;print(Q);} //调用print()void main(){char choice;rtripletable A,B,Q;cout<<"**********************************"<<endl;cout<<"*****欢迎使用稀疏矩阵运算器******"<<endl;cout<<"**********************************"<<endl;cout<<"A、输入矩阵1"<<"\t";cout<<"B、输入矩阵2"<<"\t";cout<<"C、矩阵相加"<<endl;cout<<"D、矩阵相减"<<"\t";cout<<"E、矩阵相乘"<<"\t";cout<<"F、退出本系统"<<endl;cout<<"请选择所需要的操作功能(A，B，C，D，E，F):";do{cin>>choice;switch(choice){case'A':creat(A);break;case'B':creat(B);break;case'C':addsmatrix(A,B);break;case'D':subsmatrix(A,B);break;case'E':multsmatrix(A,B,Q);break;case'F':exit(0);}cout<<"请选择所需要的操作功能(A，B，C，D，E，F):";}while(1);} 四．实验的结果及分析。
数据结构课程设计之稀疏矩阵运算器
数据结构课程设计之稀疏矩阵运算器#include#include#define maxsize 200typedef struct{int i,j;//i为非零元素在行，j为非零元所在列int e;//非零元}Tripe;typedef struct{Tripe data[maxsize];int h,l,total;//稀疏矩阵的行数列数及非零元个数}TSMatrix;void Creat(TSMatrix &M){//创建一个稀疏矩阵int a,b,c,x;scanf("%d,%d,%d",&M.h,&M.l,&M.total);for(x=1;x<=M.total;x++){printf("请输入第%d个稀疏矩阵的非零元素所在的行数列数用逗号隔开输完按回车键:\",x);scanf("%d,%d,%d",&a,&b,&c);M.data[x].i=a;M.data[x].j=b;M.data[x].e=c;}}void Print(TSMatrix &S){//输出稀疏矩阵int x;int c,b,a[maxsize][maxsize];for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++)a[c][b]=0;//全部初始化为零for(x=1;x<=S.total;x++){a[S.data[x].i][S.data[x].j]+=S.data[x].e;//在矩阵的相应位置附上非零元素}for(c=1;c<=S.h;c++)for(b=1;b<=S.l;b++){printf("%4d",a[c][b]);if(b==S.l)printf("\");}}void Add(TSMatrix T,TSMatrix V,TSMatrix &M){//加法运算int p=1,q=1;int b=1;if(T.h!=V.h||T.l!=V.l){printf("两矩阵行数或列数不同无法进行相加:\"); exit(0);}while(p<=T.total&&q<=V.total){if(T.data[p].i==V.data[q].i){if(T.data[p].j==V.data[q].j){M.data[b].i=T.data[p].i;M.data[b].e=T.data[p].e+V.data[q].e; p++;b++;q++;}else if(T.data[p].j<v.data[q].j)< p=""> {M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].j>V.data[q].j){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}}else if(T.data[p].i<v.data[q].i)< p=""> {M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}else if(T.data[p].i>V.data[q].i){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;b++;q++;}}//下面两个循环是把上面循环中未处理的数据添加到M中while(p<=T.total){M.data[b].i=T.data[p].i;M.data[b].j=T.data[p].j;M.data[b].e=T.data[p].e;b++;p++;}while(q<=V.total){M.data[b].i=V.data[q].i;M.data[b].j=V.data[q].j;M.data[b].e=V.data[q].e;b++;q++;}M.h=T.h;M.l=T.l;M.total=b-1; //b最后要减一，因为上面处理最后一个数时b也增加1了}void TransposTSMtrix(TSMatrix A,TSMatrix &B) //完成矩阵的转置，一次快速定位法{int j,t,p,q;int num[maxsize],position[maxsize];//num矩阵某列非零元个数，positionB.h=A.l;B.l=A.h;B.total=A.total;if(B.total){for(j=1;j<=A.l;j++)num[j]=0;for(t=1;t<=A.total;t++)num[A.data[t].j]++;position[1]=1;for(j=2;j<=A.l;j++)position[j]=position[j-1]+num[j-1];for(p=1;p<=A.total;p++){j=A.data[p].j;q=position[j];B.data[q].i=A.data[p].j;B.data[q].j=A.data[p].i;B.data[q].e=A.data[p].e;position[j]++;}}}void Jiansmatrix(TSMatrix M,TSMatrix N,TSMatrix &T){ int m=1,n=1,t=1;if(M.h!=N.h||M.l!=N.l){printf("两矩阵行数或列数不同无法进行相减");exit(0);} T.h=M.h;T.l=M.l;while(m<=M.total&&n<=N.total){{if(M.data[m].i==N.data[n].i)if(M.data[m].j==N.data[n].j){if(M.data[m].e==N.data[n].e){T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;m++;n++;}else{T.data[t].e=M.data[m].e-N.data[n].e; T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;n++;}}else if(M.data[m].j<n.data[n].j)< p=""> {T.data[t].e=M.data[m].e;T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;t++;m++;}else if(M.data[m].j>N.data[n].j){T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}else{if(M.data[m].i<n.data[n].i)< p=""> {T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}else {T.data[t].e=0-N.data[n].e;T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;t++;n++;}}}}while(M.total==(m-1)&&n<=N.total) {T.data[t].i=N.data[n].i;T.data[t].j=N.data[n].j;T.data[t].e=N.data[n].e;t++;n++;}while(N.total==(n-1)&&m<=M.total) {T.data[t].i=M.data[m].i;T.data[t].j=M.data[m].j;T.data[t].e=M.data[m].e;t++;m++;}T.total=t-1;}void Multsmatrix(TSMatrix M,TSMatrix N,TSMatrix &T) { int p,q,Qn=0;int a[200][200];if(M.l!=N.h){printf("两矩阵无法相乘");exit(0);}T.h=M.h;T.l=N.l;for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)a[p][q]=0;for(p=1;p<=M.total;p++)for(q=1;q<=N.total;q++)if(M.data[p].j==N.data[q].i){a[M.data[p].i][N.data[q].j]+=M.data[p].e*N.data[q].e;}for(p=1;p<=M.h;p++)for(q=1;q<=N.l;q++)if(a[p][q]!=0){Qn++;T.data[Qn].e=a[p][q];T.data[Qn].i=p;T.data[Qn].j=q;}T.total=Qn;}void main(){TSMatrix ts1,ts2,ts3;int choice;do{printf("1.矩阵的转置!\");printf("2.两个矩阵相加!\");printf("3.两个矩阵相减!\");printf("4.两个矩阵相乘!\");printf("5.退出程序!\");printf("请输入您的选择:\");scanf("%d",&choice);switch(choice){case 1:printf("请输入矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);Print(ts1);TransposTSMtrix(ts1,ts2);printf("转置后的矩阵为:\");Print(ts2);break;case 2:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Add(ts1,ts2,ts3);printf("以上两个矩阵相加后为:\");Print(ts3);break;case 3:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Jiansmatrix(ts1,ts2,ts3);printf("以上两个矩阵相减后为:\");Print(ts3);break;case 4:printf("请输入第一个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts1);printf("第一个矩阵为:\");Print(ts1);printf("请输入第二个矩阵的行和列及非零元个数用逗号隔开:\"); Creat(ts2);printf("第二个矩阵为:\");Print(ts2);Multsmatrix(ts1,ts2,ts3);printf("以上两个矩阵相乘后为:\");Print(ts3);break;case 5:exit(0);break;}}while(choice!=0); scanf("%d",&choice); }</n.data[n].i)<></n.data[n].j)<></v.data[q].i)<></v.data[q].j)<>。
稀疏矩阵(算法与数据结构课程设计)
稀疏矩阵一、问题描述假若在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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构----稀疏矩阵运算器课程设计目录稀疏矩阵运算器设计............................................................................................ 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．程序可以对三元组的输入顺序不加以限制；根据对矩阵的行列，三元组作直接插入排序，从而进行运算时,不会产生错误。
6．在用三元组表示稀疏矩阵时，相加、乘积和相减所得结果矩阵应该另生成；矩阵求逆时，为了算法方便，使用二维数组存放。
7．程序在VC6.0环境下设计。
程序执行的命令为：1.稀疏矩阵转置; 2.稀疏矩阵加法; ;3. 稀疏矩阵乘法; 4.退出的工作。
第二章概要设计1．抽象数据类型稀疏矩阵的定义如下：ADT SparseMatrix{数据对象：D={a|i=1,2,…,m; j=1,2,…,n;ij a∈ElemSet, m和n分别为矩阵的行数和列ij数} 数据关系：R={Row,Col }Row={﹤a, a﹥| 1≤i≤m, 1≤j≤n-1} i,j+1i,jCol = {﹤a, a﹥| 1≤i≤m-1, 1≤j≤n} i+1,ji,j基本操作：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-B MultSMatrix(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];tripletable(); int rpos[maxsize];~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(包含矩阵的各种运算函数)。
输入矩阵（以三元组形式输入非零元）{int k;tripletable A,B;;的行数，列数和非零元个数：A输入稀疏矩阵潣瑵?cin>>A.m>>A.n>>A.t;for(k=1;k<=A.t;k++){牰湩晴尨输入第%d个非0元素的行数，列数和值:,k);cin>>A.data[k].i>>A.data[k].j>>A.data[k].v; }输出矩阵：int c[100][100]={0};for(k=1;k<=B.t;k++){c[B.data[k].i][B.data[k].j]=B.data[k].v;}潣瑵?转置（加法，乘法）结果为：<<endl; for(k=1;k<=B.n;k++){for(int l=1;l<=B.m;l++)cout<<c[k][l]<< ;cout<<endl;}}转置矩阵：矩阵的转置// void tripletable::convert( ) {int k;tripletable A,B;潣瑵?输入稀疏矩阵A的行数，列数和非零元个数：; cin>>A.m>>A.n>>A.t;for(k=1;k<=A.t;k++){牰湩晴尨输入第%d个非0元素的行数，列数和值:,k); cin>>A.data[k].i>>A.data[k].j>>A.data[k].v;}B.m=A.m;B.n=A.n;B.t=A.t;if(B.t){int q=1,col;for(col=1;col<=A.n;++col)for(int p=1;p<=A.t;++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].v=A.data[p].v;++q;}}int shuru[100][100]={0};for(k=1;k<=B.t;k++){shuru[B.data[k].j][B.data[k].i]=B.data[k].v; }潣瑵?输入为：<<endl;for(k=1;k<=B.m;k++){for(int l=1;l<=B.n;l++)cout<<shuru[k][l]<< ;cout<<endl;}int result[100][100]={0};for(k=1;k<=B.t;k++){result[B.data[k].i][B.data[k].j]=B.data[k].v; }潣瑵?结果为：<<endl;for(k=1;k<=B.n;k++){for(int l=1;l<=B.m;l++)cout<<result[k][l]<< ;cout<<endl;}}以上主要设计思想：通过三元组输入一个矩阵A，为了找到A的每一列中所有非零元素，需要对其三元组表A.data从第一行起整个扫描一遍，由于A.data是以A的行序为主序来存放每个非零元的，由此得到的恰是B.data的应有的顺序。
加法矩阵：void tripletable::add( ) //矩阵的加法{int k;tripletable A,B;潣瑵?输入稀疏矩阵A的行数，列数和非零元个数：;cin>>A.m>>A.n>>A.t;for(k=1;k<=A.t;k++){牰湩晴尨输入第%d个非0元素的行数，列数和值:,k);cin>>A.data[k].i>>A.data[k].j>>A.data[k].v;}潣瑵?输入稀疏矩阵B的行数，列数和非零元个数：;cin>>B.m>>B.n>>B.t;for(k=1;k<=B.t;k++){牰湩晴尨输入第%d个非0元素的行数，列数和值:,k);cin>>B.data[k].i>>B.data[k].j>>B.data[k].v;}if(A.m!=B.m||A.n!=B.n){潣瑵?输入错误：A与B的行数或列数不相同，请重新输入<<endl; return;}int a[100][100]={0};for(k=1;k<=A.t;k++){a[A.data[k].i][A.data[k].j]=A.data[k].v;}cout<<A输入为：<<endl;for(k=1;k<=A.m;k++){for(int l=1;l<=A.n;l++)cout<<a[k][l]<< ;cout<<endl;}int b[100][100]={0};for(k=1;k<=B.t;k++){b[B.data[k].i][B.data[k].j]=B.data[k].v; }cout<<B输入为：<<endl;for(k=1;k<=B.m;k++){for(int l=1;l<=B.n;l++)cout<<b[k][l]<< ;cout<<endl;}int c[100][100]={0};for(k=1;k<=A.m;k++){for(int l=1;l<=A.n;l++){c[k][l]=a[k][l]+b[k][l];}}潣瑵?加法结果C为：<<endl;for(k=1;k<=A.m;k++){for(int l=1;l<=A.n;l++)cout<<c[k][l]<< ;cout<<endl;}}以上主要设计思想：此功能由函数add( )实现，当用户选择该功能时系统即提示用户初始化要进行加法的两个矩阵的信息。