数据结构_基于三元组表的储存结构实现稀疏矩阵操作_课程设计_实验报告
数据结构-稀疏矩阵实验报告
实验报告
课程 学号 数据结构 姓名 实验名称 实验四 稀疏矩阵 实验日 期： 2012/11/12
实验四 实验目的：稀疏矩阵1.熟悉数组在计算机内存中存储的实现机制； 2.熟练并掌握数组的基本运算； 3.熟悉并掌握特殊矩阵的压缩存储方法及压缩存储下的矩阵的运算； 3.熟悉稀疏矩阵的“三元组表”和“十字链表”存储结构。
if(i<=j) { for(k=1;k<=n;k++) { if(i<=k) p=k*(k-1)/2+i-1; else p=n*(n+1)/2; if(j>=k) q=j*(j-1)/2+k-1; else q=n*(n+1)/2; sum=sum+a[p]*b[q]; } c[j*(j-1)/2+i-1]=sum; sum=0; } else c[n*(n+1)/2]=0; } } void print(int a[], int n) { int i,j; for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { if(i<=j) printf("%5d", a[j*(j-1)/2+i-1]); else printf("%5d", a[n*(n+1)/2]); } printf("\n"); } } void main() { int u[]={1,2,4,3,5,6,0}; int v[]={10,20,40,30,50,60,0}; int c[7], n=3; add(u,v,c,n); printf("C=A+B=\n"); print(c,n);
数据结构实验四稀疏矩阵运算
数据结构实验四稀疏矩阵运算1、实验目的掌握三元组法存储稀疏矩阵的方法及相关的基本操作。
2、实验内容∙用三元组法存放稀疏矩阵∙求出矩阵转置结果∙求出矩阵相乘结果∙输出结果矩阵3、实验要求∙用数组存放矩阵的三元组，矩阵的行数和列数及非0数据从键盘输入∙要求采用稀疏矩阵快速转置算法∙若两个矩阵不能相乘则输出“Error”4、试验参考程序typedef s tr uct { // 定义三元组的元素int i, j;int e;} Tr iple;typedef s tr uct { // 定义矩阵Tr iple data[MA XSI ZE + 1];int mu, nu, tu;} TSMa tr ix;typedef s tr uct { // 定义行逻辑连接矩阵Tr iple data[MA XSI ZE + 2];int rpos[MA XROW + 1];int mu, nu, tu;} RLSMatr ix;矩阵输入函数bool InPutT SMat r ix(T SMatr ix & T) {cout << "输入矩阵的行，列和非零元素个数:" << e ndl;cin >> T.mu >> T.nu >> T.tu;cout << "请输出非零元素的位置和值:" << e ndl;for (int k = 1;; k <= T.t u; k++)cin >> T.data[k].i >> T.da ta[k].j >> T.data[k].e;retur n t rue;}请补充完成下列矩阵转置函数、矩阵乘法函数与矩阵输出函数Bool Trans poseSMa tr ix(T SMa t r ix M, T SMat r ix & T){TSMatrix M,T; //定义预转置的矩阵InPutTSMatrix(M, 0); //输入矩阵int num[MAXROW+1];int cpot[MAXROW+1]; // 构建辅助数组int q,p,t;T.tu=M.tu; T.mu=M.nu; T.nu=M.mu;if(T.tu){for(int col=1;col<=M.nu;col++) num[col]=0;for(t=1;t<=M.tu;t++) ++num[M.data[t].j];cpot[1]=1;for(int i=2;i<=M.nu;i++) cpot[i]=cpot[i-1]+num[i-1]; // 求出每一列中非零元素在三元组中出现的位置for(p=1;p<=M.tu;p++){col=M.data[p].j; q=cpot[col];T.data[q].i=col; T.data[q].j=M.data[p].i;T.data[q].e=M.data[p].e; ++cpot[col];}}cout<<"输入矩阵的转置矩阵为"<<endl;OutPutSMatrix(T);return true;}Bool MultSMatr ix(RLSMatr ix M, RL SMatr ix N，RL SMat r ix & T){RLSMatrix M,N,Q; // 构建三个带“链接信息”的三元组表示的数组InPutTSMatrix(M,1); // 用普通三元组形式输入数组InPutTSMatrix(N,1);Count(M); Count(N);if(M.nu!=N.mu) return false;Q.mu=M.mu; Q.nu=N.nu; Q.tu=0; // Q初始化int ctemp[MAXROW+1]; // 辅助数组int arow,tp,p,brow,t,q,ccol;if(M.tu*N.tu){ // Q是非零矩阵for( arow=1;arow<=M.mu;arow++){///memset(ctemp,0,N.nu);for(int x=1;x<=N.nu;x++) // 当前行各元素累加器清零ctemp[x]=0;Q.rpos[arow]=Q.tu+1; // 当前行的首个非零元素在三元组中的位置为此行前所有非零元素+1 if(arow<M.mu) tp=M.rpos[arow+1];else tp=M.tu+1;for(p=M.rpos[arow];p<tp;p++){ // 对当前行每个非零元素进行操作brow=M.data[p].j; // 在N中找到i值也操作元素的j值相等的行if(brow<N.mu) t=N.rpos[brow+1];else t=N.tu+1;for(q=N.rpos[brow];q<t;q++){ // 对找出的行当每个非零元素进行操作ccol=N.data[q].j;ctemp[ccol] += M.data[p].e*N.data[q].e; // 将乘得到对应值放在相应的元素累加器里面}}for(ccol=1;ccol<=Q.nu;ccol++) // 对已经求出的累加器中的值压缩到Q中if(ctemp[ccol]){if(++Q.tu>MAXSIZE) return false;Q.data[Q.tu].e=ctemp[ccol];Q.data[Q.tu].i=arow;Q.data[Q.tu].j=ccol;}}OutPutSMatrix(Q);return true;}}boo l O utP utSMatrix(T SMat r ix T){// 输出矩阵，按标准格式输出int m,n,k=1;fo r(m=0;m<T.mu;m++){fo r(n=0;n<T.nu;n++){if((T.d a ta[k].i-1)==m&&(T.d a ta[k].j-1)==n){co ut.w id th(4);co ut<<T.d a ta[k++].e;}e ls e{co ut.w id th(4); co ut<<"0"; }}co ut<<e nd l;}re turn true;}}并建立ma in（）函数对上述函数进行测试。
三元组顺序表稀疏矩阵课程设计报告(不完整)
1.稀疏矩阵运算器数据结构课程设计任务书针对本课程设计，完成以下课程设计任务：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.编写实验报告。
实验结果：经过实验测试，稀疏矩阵的加法和乘法算法都能正确运行，并且在处理稀疏矩阵时能够有效节省存储空间。
性能测试结果表明，稀疏矩阵加法、乘法的运行时间与非零元素个数有关，当非零元素个数较少时，运算速度较快；当非零元素个数较多时，运算速度较慢。
实验分析：稀疏矩阵的运算相对于普通矩阵的运算有明显的优势，可以节省存储空间和运算时间。
在实际应用中，稀疏矩阵的存储方式和运算算法都可以进行优化。
例如，可以采用行逻辑链接表的方式存储稀疏矩阵，进一步减少存储空间的占用；可以采用并行计算的策略加快稀疏矩阵的运算速度。
总结：通过本次实验，我深入学习了稀疏矩阵的概念、特点和存储方式，掌握了稀疏矩阵加法、乘法的基本思想和算法，并通过实验实现了稀疏矩阵的加法、乘法运算。
稀疏矩阵编程实验报告
一、实验目的1. 理解稀疏矩阵的概念及其存储方式。
2. 掌握稀疏矩阵的基本操作，包括转置、加法、减法和乘法。
3. 通过编程实践，提高对数据结构和算法的理解和应用能力。
二、实验环境1. 编程语言：C语言2. 开发环境：Visual Studio 20193. 操作系统：Windows 10三、实验内容1. 稀疏矩阵的三元组表示及其实现2. 稀疏矩阵的转置3. 稀疏矩阵的加法、减法和乘法四、实验步骤1. 稀疏矩阵的三元组表示及其实现（1）定义稀疏矩阵的三元组结构体：```ctypedef struct {int row; // 行号int col; // 列号double val; // 非零元素值} Triple;```（2）定义稀疏矩阵结构体：typedef struct {int rows; // 矩阵行数int cols; // 矩阵列数int nums; // 非零元素个数Triple data; // 非零元素的三元组数组} SparseMatrix;```（3）编写函数实现稀疏矩阵的创建：```cvoid createSparseMatrix(SparseMatrix sm, int rows, int cols, int nums) { sm->rows = rows;sm->cols = cols;sm->nums = nums;sm->data = (Triple )malloc(nums sizeof(Triple));}```（4）编写函数实现稀疏矩阵的销毁：```cvoid destroySparseMatrix(SparseMatrix sm) {free(sm->data);sm->data = NULL;}2. 稀疏矩阵的转置（1）编写函数实现稀疏矩阵的转置：```cvoid transposeSparseMatrix(SparseMatrix src, SparseMatrix dst) {dst->rows = src->cols;dst->cols = src->rows;dst->nums = src->nums;dst->data = (Triple )malloc(src->nums sizeof(Triple));for (int i = 0; i < src->nums; i++) {dst->data[i].row = src->data[i].col;dst->data[i].col = src->data[i].row;dst->data[i].val = src->data[i].val;}}```3. 稀疏矩阵的加法、减法和乘法（1）编写函数实现稀疏矩阵的加法：```cvoid addSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val + sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val += sm2->data[j].val;}}}}}```（2）编写函数实现稀疏矩阵的减法：```cvoid subSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val - sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val -= sm2->data[j].val;}}}}}```（3）编写函数实现稀疏矩阵的乘法：```cvoid mulSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm2->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].col == sm2->data[j].row) {double sum = 0;for (int k = 0; k < sm1->nums; k++) {if (sm1->data[k].col == sm2->data[j].row) {sum += sm1->data[k].val sm2->data[j].val;}}if (sum != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val = sum;}}}}}```五、实验结果与分析1. 通过编程实现稀疏矩阵的基本操作，验证了算法的正确性。
数据结构课程设计稀疏矩阵
稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。
在程序设计中，考虑到方法的难易程度，采用了先用三元组实现稀疏矩阵的输入，输出，及其转置，相加，相乘操作的方法，再在十字链表下实现。
程序通过调试运行，结果与预期一样，初步实现了设计目标。
关键词程序设计；稀疏矩阵；三元组；十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。
稀疏矩阵采用三元组和十字链表表示，并在两种不同的存储结构下，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；求出A的转置矩阵D，输出D；求两个稀疏矩阵A和B的相乘矩阵E，并输出E。
1.2课程设计性质数据结构课程设计是重要地实践性教学环节。
在进行了程序设计语言课和《数据结构》课程教学的基础上，设计实现相关的数据结构经典问题，有助于加深对数据结构课程的认识。
本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现，包括在三元组和十字链表下存储稀疏矩阵，并对输入的稀疏矩阵进行转置，相加，相乘等操作，最后把运算结果输出。
此课程设计要求对数组存储结构和链表存储结构非常熟悉，并能熟练使用它们。
1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上，掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置，相加，相乘等基本操作，并用不同的方法输出结果，进一步掌握设计、实现较大系统的完整过程，包括系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及操作方法，为进一步的应用开发打好基础。
2需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化，包括在三元组结构下和十字链表结构下。
首先要定义两种不同的结构体类型，在创建稀疏矩阵时，需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵，在输入出现错误时，能够对错误进行判别处理，初始化稀疏矩阵都为空值，特别注意在十字链表下，对变量进行动态的地址分配。
java稀疏矩阵的三元组存储
=====实习报告三“稀疏矩阵的三元组存储”演示程序======（一）、程序的功能和特点1. 程序功能：建立稀疏矩阵的三元组存储，可以键盘输入所要存储的稀疏矩阵，能将输入的稀疏矩阵显示输出。
2. 程序特点：采用java面向对象语言，将三元组和稀疏矩阵用类进行封装。
能方便的储存稀疏，方便的显示稀疏矩阵。
（二）、程序的算法设计算法一：“显示输出稀疏矩阵”算法：1.【逻辑结构与存储结构设计】逻辑结构：线性结构。
存储结构：顺序存储结构。
数组采用三元组顺序存储方法存储该表。
2.【基本操作设计】3.【算法设计】i j v1 1 1 152 1 4 223 1 6 -154 2 2 115 2 3 36 3 4 67 5 1 91 三元组表15 0 0 22 0 -150 11 3 0 0 00 0 0 60 00 0 0 00 091 0 0 00 00 0 0 00 0稀疏矩阵A=开始输出命令输出该稀疏矩阵的行数和列数。
利用for循环按先行后列顺序输出矩阵循环访问稀疏矩阵的每一个元素，通过行号和列号找到稀疏矩阵的在三元组表中是否有存储，若有则输出其值，若没有则输出0.文字说明：（1）.首先输出稀疏矩阵的行数和列数。
（2）.在通过for 循环依次访问该稀疏矩阵的每一个元素，比较行号和列号，如果行号和列号和三元组所存储的相同，则输出其值;（3）.如果不相同或三元数组没有储存则该元素值为零; （4）.输出结束。
4.【高级语言代码】 //显示输出稀疏矩阵 void display(){ int i,j,k;System.out .println("稀疏矩阵的行数 "+Rows ); System.out .println("稀疏矩阵的列数 "+Cols ); //按先行后列顺序输出矩阵 for (i=0;i<Rows ;i++) { for (j=0;j<Cols ;j++) {for (k=0;k<Terms ;k++) //查三元组表if (i==smArray [k].row &&j==smArray [k].col ){ System.out .print(smArray [k].value +" "); break ; //打断k 循环 }if (k==Terms ) System.out .print("0.0 "); }System.out .println(); //换行 } }（三）、程序中类的设计“Trituple ”类：1.【逻辑结构与存储结构】 逻辑结构：线性结构。
稀疏矩阵的存储和快速转置实验报告
福建工程学院课程设计课程：数据结构题目：稀疏矩阵的快速转置专业：运算机类班级：座号：姓名：2021年6月25日实验题目：稀疏矩阵的快速转置一、要解决的问题利用三元组表存储稀疏矩阵，利用快速转置算法进行转置，并输出转置之前和以后的三元组表和矩阵。
二、算法大体思想描述：由于稀疏矩阵的非零元素较少，零元素较多，因此只需存储其非零元素。
因此能够成立一个三元组表，别离保存稀疏矩阵的非零元素的行号、列号和元素值。
对稀疏矩阵进行快速转置是能够引入两个向量num[n+1],cpot[n+1],别离标记矩阵中第col列的非零元素个数和第一个非零元素在转置后的矩阵的位置；再扫描三元组表，找到非零元素，直接对其在转置后的矩阵所在的位置上进行修改，以节省时刻。
三、详细设计⒈元素类型，结点类型typedef struct {int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;} Tsmatrix;2.对抽象数据类型中的部份大体操作的伪码算法如下：Tsmatrix * creatarray(Tsmatrix *M){ int m,n,p=1;int c;printf("please input the array A:\n");for(m=1;m<=a;m++)for(n=1;n<=b;n++){ scanf("%d",&c);if(c!=0){ M->data[p].e=c;M->data[p].i=m;M->data[p].j=n;p++;}}M->tu=p; M->mu=a; M->nu=b;printf("yuan lai san yuan zu de biao shi wei :\n\n");for(m=1;m<=M->tu;m++)printf("%3d%3d%3d\t",M->data[m].i,M->data[m].j,M->data[m].e);printf("\n");return M;}/*三元组快速转置*/Tsmatrix * fasttrans(Tsmatrix *M,Tsmatrix *T){ int p,col,q,t,m;int num[100];int cpot[100];T->mu=M->nu; T->nu=M->mu; T->tu=M->tu;if(T->tu!=0){for(col=1;col<=M->nu;col++) num[col]=0;for(t=1;t<=M->tu;t++) ++num[M->data[t].j];cpot[1]=1;for(col=2;col<=M->nu;col++) cpot[col]=cpot[col-1]+num[col-1];for(p=1;p<=M->tu;++p){ col=M->data[p].j; q=cpot[col];T->data[q].i=M->data[p].j;T->data[q].j=M->data[p].i;T->data[q].e=M->data[p].e;++cpot[col];}}printf("\n\nzhuan zhi hou de san yuan zu biao shi wei :\n\n");for(m=1;m<=T->tu;m++)printf("%3d%3d%3d\t",T->data[m].i,T->data[m].j,T->data[m].e);printf("\n");return T;}/*输出三元组函数*/void print(Tsmatrix *T,int x,int y){ int m,n,p=1;int d;for(m=1;m<=x;m++){ printf("\n");for(n=1;n<=y;n++){ if(T->data[p].i==m&&T->data[p].j==n){ d=T->data[p].e;p++;}else d=0;printf("%6d",d);}}}}3.主函数和其他函数的伪码算法void main(){ Tsmatrix *M,*T;M=(Tsmatrix *)malloc(sizeof(Tsmatrix));T=(Tsmatrix *)malloc(sizeof(Tsmatrix));printf("please input array's row and col:\n");scanf("%d%d",&a,&b); /*输入行列数*/ M=creatarray(M); /*创建稀疏矩阵*/printf("you had creat the array:\n");print(M,a,b); /*输出创建好的三元组*/T=fasttrans(M,T); /*将三元组转置*/printf("the trans array is:\n");print(T,b,a);getch();}4、模块结构及功能}四、源程序清单：#include<>#define MAXSIZE 100typedef struct {int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;} Tsmatrix;int a,b; /*概念全局变量数组的行数a和列数b*//*用数组创建三元组*/Tsmatrix * creatarray(Tsmatrix *M){ int m,n,p=1;int c;printf("please input the array A:\n");for(m=1;m<=a;m++)for(n=1;n<=b;n++){ scanf("%d",&c);if(c!=0){ M->data[p].e=c;M->data[p].i=m;M->data[p].j=n;p++;}}M->tu=p; M->mu=a; M->nu=b;printf("yuan lai san yuan zu de biao shi wei :\n\n");for(m=1;m<M->tu;m++)printf("%3d%3d%3d\t",M->data[m].i,M->data[m].j,M->data[m].e);printf("\n");return M;}/*三元组快速转置*/Tsmatrix * fasttrans(Tsmatrix *M,Tsmatrix *T){ int p,col,q,t,m;int num[100];int cpot[100];T->mu=M->nu; T->nu=M->mu; T->tu=M->tu;if(T->tu!=0){for(col=1;col<=M->nu;col++) num[col]=0;for(t=1;t<=M->tu;t++) ++num[M->data[t].j];cpot[1]=1;for(col=2;col<=M->nu;col++) cpot[col]=cpot[col-1]+num[col-1];for(p=1;p<=M->tu;++p){ col=M->data[p].j; q=cpot[col];T->data[q].i=M->data[p].j;T->data[q].j=M->data[p].i;T->data[q].e=M->data[p].e;++cpot[col];}}printf("\n\nzhuan zhi hou de san yuan zu biao shi wei :\n\n");for(m=1;m<T->tu;m++)printf("%3d%3d%3d\t",T->data[m].i,T->data[m].j,T->data[m].e);printf("\n");return T;}/*输出三元组函数*/void print(Tsmatrix *T,int x,int y){ int m,n,p=1;int d;for(m=1;m<=x;m++){ printf("\n");for(n=1;n<=y;n++){ if(T->data[p].i==m&&T->data[p].j==n){ d=T->data[p].e;p++;}else d=0;printf("%6d",d);}}}void main(){ Tsmatrix *M,*T;M=(Tsmatrix *)malloc(sizeof(Tsmatrix));T=(Tsmatrix *)malloc(sizeof(Tsmatrix));printf("please input array's row and col:\n");scanf("%d%d",&a,&b); /*输入行列数*/M=creatarray(M);printf("you had creat the array:\n");print(M,a,b);T=fasttrans(M,T);printf("the trans array is:\n");print(T,b,a);getch();}五、测试数据及测试结果：（1）我输入的稀疏矩阵为：（2）回车显示的结果是：六、课程设计总结及心得体会：通过本次课程设计，我对有关稀疏矩阵及其三元组表的知识做了温习和巩固。
数据结构实验报告稀疏矩阵运算
教学单位计算机科学与技术学生学号************数据结构课程设计报告书题目稀疏矩阵运算器学生姓名秦豹专业名称软件工程指导教师李志敏实验目的：深入研究数组的存储表示和实现技术，熟悉广义表存储结构的特性。
需要分析：稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
要求以带“行逻辑链接信息”的三元组顺序表存储稀疏矩阵，实现两矩阵的相加、相减、相乘等运算。
输入以三元组表示，输出以通常的阵列形式列出。
软件平台：Windows 2000，Visual C＋＋6.0或WINTC概要设计：ADT Array {数据对象:D = {aij | 0≤i≤b1-1, 0 ≤j≤b2-1}数据关系:R = { ROW, COL }ROW = {<ai,j,ai+1,j>| 0≤i≤b1-2, 0≤j≤b2-1}COL = {<ai,j,ai,j+1>| 0≤i≤b1-1, 0≤j≤b2-2}基本操作：CreateSMatrix(&M); //操作结果:创建稀疏矩阵M.Print SMatrix(M);//初始化条件: 稀疏矩阵M存在.//操作结果:输出稀疏矩阵M.AddSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的和Q=M+N.SubSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的差Q=M-N.MultSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M的列数等于N的行数.//操作结果:求稀疏矩阵的乘积Q=M*N.} ADT Array调试测试：初始界面矩阵的加法矩阵的减法矩阵的转置矩阵的乘法程序源码：#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define MAXSIZE 40 //假设非零元素个数的最大值为40#define MAXRC 20 //假设矩阵的最大行数为20typedef int ElemType;typedef struct{int i,j; //非零元的行下标和列下标ElemType e; //非零元的值}Triple;typedef struct{Triple data[MAXSIZE+1];int rpos[MAXRC+1]; //各行第一个非零元在三元组的位置表int hs,ls,fls;}TSMatrix,*Matrix;void Creat(TSMatrix &M){int i,k;for(i=1;i<=MAXRC+1;i++)M.rpos[i]=0;printf("请输入矩阵的行数、列数和非零元个数(以空格隔开):");scanf("%d %d %d",&M.hs,&M.ls,&M.fls);for(i=1;i<=M.fls;i++){printf("请用三元组形式输入矩阵的元素(行列非零元素):");scanf("%d %d %d",&M.data[i].i,&M.data[i].j,&M.data[i].e);}for(i=1,k=1;i<=M.hs;i++){M.rpos[i]=k;while(M.data[k].i<=i && k<=M.fls)k++;}}void Xiangjia(TSMatrix A,TSMatrix B,TSMatrix &C,int n){int a,b,temp,l;C.hs=A.hs;C.ls=A.ls;a=b=l=1;while(a<=A.fls && b<=B.fls){if(A.data[a].i==B.data[b].i){if(A.data[a].j<B.data[b].j)C.data[l++]=A.data[a++];else if(A.data[a].j>B.data[b].j){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}else{temp=A.data[a].e+n*B.data[b].e;if(temp){C.data[l]=A.data[a];C.data[l].e=temp;l++;}a++;b++;}}else if(A.data[a].i<B.data[b].i)C.data[l++]=A.data[a++];else {C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;} }while(a<=A.fls)C.data[l++]=A.data[a++];while(b<=B.fls){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}C.fls=l-1;}int Xiangcheng(TSMatrix A,TSMatrix B,TSMatrix &Q){int arow,brow,ccol,tp,p,q,t;int ctemp[MAXRC+1];if(A.ls!=B.hs) return 0;Q.hs=A.hs;Q.ls=B.ls;Q.fls=0;if(A.fls*B.fls){for(arow=1;arow<=A.hs;arow++){for(ccol=1;ccol<=Q.ls;ccol++)ctemp[ccol]=0;Q.rpos[arow]=Q.fls+1;if(arow<A.hs) tp=A.rpos[arow+1];else tp=A.fls+1;for(p=A.rpos[arow];p<tp;p++){brow=A.data[p].j;if(brow<B.hs) t=B.rpos[brow+1];else t=B.fls+1;for(q=B.rpos[brow];q<t;q++){ccol=B.data[q].j;ctemp[ccol]+=A.data[p].e*B.data[q].e;}}for(ccol=1;ccol<=Q.ls;ccol++){if(ctemp[ccol]){if(++Q.fls>MAXSIZE) return 0;Q.data[Q.fls].i=arow;Q.data[Q.fls].j=ccol;Q.data[Q.fls].e=ctemp[ccol];}}}}return 1;}void Print_SMatrix(TSMatrix M){int k,l,n;Matrix p;p=&M;for(k=1,n=1;k<=p->hs;k++){for(l=1;l<=p->ls;l++){if(p->data[n].i==k && p->data[n].j==l){printf("%5d",p->data[n].e);n++;}elseprintf("%5d",0);}printf("\n");}printf("\n");}void Zhuanzhi(TSMatrix *a,TSMatrix *b){int q,col,p;b->hs=a->ls;b->ls=a->hs;b->fls=a->fls;if(b->fls){q=1;for(col=1;col<=a->ls;col++)for(p=1;p<=a->fls;p++)if(a->data[p].j==col){b->data[q].i=a->data[p].j;b->data[q].j=a->data[p].i;b->data[q].e=a->data[p].e;++q;}}}void Destory_SMatrix(TSMatrix &M){M.hs=M.ls=M.fls=0;}void main(){TSMatrix A,B,C;TSMatrix *p=&A,*q=&B;int flag,n;while(1){system("cls");printf("\n\n\n");printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("\t┃*** 稀疏矩阵的加、减、转、乘*** ┃\n");printf("\t┣━━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n");printf("\t┃1、稀疏矩阵的加法┃\n");printf("\t┃2、稀疏矩阵的减法┃\n");printf("\t┃3、稀疏矩阵的转置┃\n");printf("\t┃4、稀疏矩阵的乘法┃\n");printf("\t┃5、退出该应用程序┃\n");printf("\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf("输入要进行的项目的编号:");scanf("%d",&flag);if(flag==5) break;Creat(A);printf("矩阵A:\n"); Print_SMatrix(A);switch(flag){case 1: Creat(B);n=1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A+B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 2: Creat(B);n=-1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A-B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 3: printf("A->B:\n");Zhuanzhi(p,q);Print_SMatrix(B);break;case 4: Creat(B);printf("矩阵B:\n");Print_SMatrix(B);printf("A*B:\n");n=Xiangcheng(A,B,C);if(!n) printf("错误!行列不匹配\n");else Print_SMatrix(C);break;default: printf("输入错误!\n");}Destory_SMatrix(A);Destory_SMatrix(B);Destory_SMatrix(C);getchar();getchar();}printf("\n\t\t\t ***程序已经退出***\n");getchar();}小结：。
稀疏矩阵基本操作 实验报告
稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵的压缩储存结构，以及稀疏矩阵的三元组表表示方法下的转置、相加、相乘等算法二、实验目的1.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义，掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素（三元组分别储存非零元素的行下标，列下标和元素值）。
除了三元组表本身，储存一个稀疏矩阵还需要额外的三个变量，分别储存矩阵的非零元个数，矩阵的行数和矩阵的列数。
2.稀疏矩阵的创建算法：第一步：根据矩阵创建一个二维数组，表示原始矩阵第二步：取出二维数组中的元素（从第一个元素开始取），判断取出元素是否为非零元素，如果为非零元素，把该非零元素的数值以及行下标和列下表储存到三元数组表里，否则取出下一个元素，重复该步骤。
第三步：重复第二步，知道二维数组中所有的元素已经取出。
3.稀疏矩阵倒置算法：第一步：判断进行倒置的矩阵是否为空矩阵，如果是，则直接返回错误信息。
第二步：计算要倒置的矩阵每列非零元素的数量，存入到num数组（其中num[i] 代表矩阵中第i列非零元素的个数）。
以及倒置后矩阵每行首非零元的位置，存入cpot 数组中（其中cpot表示倒置后矩阵每行非零元的位置，对应表示原矩阵每列中第一个非零元的位置）。
第三步：确定倒置后矩阵的行数和列数。
第四步：取出表示要导致矩阵中三元组表元素{e, I, j}（第一次取出第一个，依次取出下一个元素），从第二步cpot数组中确定该元素倒置后存放的位置（cpot[j]），把该元素的行下标和列下标倒置以后放入新表的指定位置中。
cpot[j] 变量加一。
第五步：重复第四步，直到三元组表中所有的元素都完成倒置。
第六步：把完成倒置运算的三元组表输出。
4.稀疏矩阵加法算法：第一步：检查相加两个矩阵的行数和列数是否相同，如果相同，则进入第二步，否则输出错误信息。
第二步：定义变量i和j，用于控制三元组表的遍历。
稀疏矩阵实验报告（包括问题描述，源代码，实验结果等）
数据结构课程设计实习报告题目：班级：学号：姓名：实习报告1．问题描述稀疏矩阵的操作基本功能要求：(1)稀疏矩阵采用三元组表示，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C。
(2)求出A的转置矩阵D，输出D。
2．设计1）设计思想矩阵中如果多数的元素没有数据，则会造成存储器空间的浪费，为此，必须设计稀疏矩阵的阵列储存方式，利用较少的存储器空间储存完整的矩阵数据。
但是这些存储空间的大部分存放的是0元素,从而造成大量的空间浪费.为了节省存储空间,可以只存储其中的非0元素. 对于矩阵Amn的每个元素aij,知道其行号i 和列号j就可以确定其位置.因此对于稀疏矩阵可以用一个结点来存储一个非0元素.该结点可以定义成: [i,j,aij]创建一个矩阵A和矩阵B，这两个稀疏矩阵具有相同行列数，然后矩阵A与矩阵B相加得到矩阵C，并输出C，稀疏矩阵采用三元组表示。
并调用原矩阵A 转置得到矩阵D，输出D。
2) 设计表示法(1) 函数调用关系如图所示。
3）实现注释：实现了原题中要求的：两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；得到矩阵A的转置矩阵D，输出D；稀疏矩阵均采用三元组表示。
3．调试报告调试程序时，应注意矩阵的调用。
比如，开始的时候没有注意将程序调用，最后尽管实现了矩阵的转置和相加，但没有符合题意。
题目要求的是用创建好的矩阵A和矩阵B进行相加，并对矩阵A进行转置，所以要调用好矩阵。
4．程序清单#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu; //mu、nu为稀疏矩阵的行列数，tu为稀疏矩阵的非零元素个数}TSMatrix;TSMatrix M,T,S,B,C;void CreateMatrix(TSMatrix &M){int i,elem,col,row,mu,nu,tu;printf("请输入稀疏矩阵的行数、列数和非零元素的个数:\n");scanf("%d%d%d",&mu,&nu,&tu);M.mu=mu;M.nu=nu;M.tu=tu;for (i=1;i<=tu;i++){printf("请输入非零元素的行号、列号和值:\n");scanf("%d%d%d",&col,&row,&elem);if ( mu<=1 || col>M.mu ||nu<=1 || row>M.nu){printf("error!");exit(0);}else{M.data[i].i=col; //输出这个三元组M.data[i].j=row;M.data[i].e=elem;}}}void FastTransposeSMatrix(TSMatrix M) /*求转置矩阵*/ {int num[100];int cpot[100];int p,q,t,col=0;T.mu=M.nu; // 给T的行、列数与非零元素个数赋值T.nu=M.mu;T.tu=M.tu;if(T.tu){for(col=1;col<=M.nu;col++){num[col]=0;}for(t=1;t<=M.tu;t++){num[M.data[t].j]++;}cpot[1]=1;for(col=2;col<=M.nu;col++){cpot[col]=cpot[col-1]+num[col-1];}for(p=1;p<=M.tu;++p){col=M.data[p].j;q=cpot[col];T.data[q].i=M.data[p].j;T.data[q].j=M.data[p].i;T.data[q].e=M.data[p].e;cpot[col]++;}} TSMatrix(T);}void TSMatrix_add(TSMatrix M,TSMatrix T,TSMatrix &ADD) /*求矩阵的和*/ {int a=1,b=1,c=1,x;ADD.mu=M.mu;ADD.nu=M.nu;ADD.tu=0;for(x=1;x<=M.mu;x++){while(M.data[a].i==x&&T.data[b].i==x){if(M.data[a].j==T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e+T.data[b].e;c++;a++;b++;}else if(M.data[a].j<T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;}else{ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}while(M.data[a].i==x){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;while(T.data[b].i==x){ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}ADD.tu=c-1;}void ShowMatrix(TSMatrix &M) /*打印出矩阵*/ {int i=1,j=1,dir=1;//printf("稀疏矩阵为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++){if(M.data[dir].i==i && M.data[dir].j==j) {printf("%d ",M.data[dir].e);dir++;}elseprintf("0 ");}printf("\n");}void main(){while(1){int c;M.mu=0;M.nu=0;M.tu=0;printf("1.创建一个稀疏矩阵A:\n");printf("2.求转置矩阵A:\n");printf("3.创建一个稀疏矩阵B:\n");printf("4.求转置矩阵B:\n");printf("5.求A与B原矩阵的和:\n"); while (1){printf("请按键选择:");scanf("%d",&c);switch(c){case 1:CreateMatrix(M) ;break;case 2:FastTransposeSMatrix(M);printf("原矩阵A为:\n");ShowMatrix(M);printf("转置矩阵为:\n"); ShowMatrix(T);break;case 3:CreateMatrix(B) ;break;case 4:FastTransposeSMatrix(B);printf("原矩阵B为:\n");ShowMatrix(B);printf("转置矩阵为:\n");ShowMatrix(T);break;case 5:FastTransposeSMatrix(M);TSMatrix_add(M,B,S);printf("A与B原矩阵的和为:\n");ShowMatrix(S);break;return 0;}}}}5．结果分析（1）选择选项1，创建矩阵A；选择选项2，转置矩阵A。
基于三元组表的存储结构实现稀疏矩阵的应用课程设计,实验报告
基于三元组表的存储结构实现稀疏矩阵的应用课程设计，实验报告数据结构课程设计设计题目:基于三元组表的存储结构实现稀疏矩阵的应用学生姓名: 专业班级: 指导教师: 完成时间:信息工程学院信科系课程设计成绩评定表(本科)课题名称基于三元组表的存储结构实现稀疏矩阵的基本操作院系年级专业学号姓名成绩1、课题设计目的:(1)掌握稀疏矩阵三元组表的存储、创建、显示、转置。
(2)利用三元组表实现矩阵的相加、减。
(3)了解稀疏矩阵的相关应用。
2、课题设计意义:本次课题设计可以使我们更熟练的掌握有关三元组表及稀疏课题设计矩阵的相关知识，比一般存储方法节省了存储空间，基于三元组表目的与的存储结构实现了稀疏矩阵的基本操作。
设计意义本次课程设计是本组成员共同努力而完成的，第一次进行课程设计是我们的探索过程，这个过程中，我们克服了一个个困难，在摸索中前行，我们相信通过此次课程设计我们每个人都会对数据结构这门课程有更深一步的了解。
指导教师:年月日目录一、课题设计目的及意义 ............................................11.1、课题设计目的 (1)1.2、课程设计意义 (1)二、需求分析 (1)2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值 (1)2.2 构造函数进行稀疏矩阵的转置并输出结果 (1)2.3 构造函数进行两稀疏矩阵相加、减及相乘并输出最终稀疏矩阵 (1)2.4 退出系统 (2)三、项目设计 (2)3.1结构设计 (2)3.2算法思想 (2)3.3模块图 (2)3.4流程图 (3)四、系统实现 (4)4.1主调函数 (4)4.2三元组表建立 (4)4.3矩阵建立 (4)4.4矩阵相加减及转置 (5)五、系统调试 (8)5.1主菜单输出 (8)5.2矩阵相加 (9)5.3矩阵转置 (9)5.4矩阵相减 (10)六、实验总结 (10)七、附录 (11)一、课题设计目的及意义1.1、课题设计目的(1)掌握稀疏矩阵三元组表的存储，创建，显示，转置等方法。
稀疏矩阵三元组实验报告
一、设计人员相关信息
1.设计者姓名、学号和班号：12地信李晓婧12012242983
2.设计日期：2014.
3.上机环境：VC++6.0
二、程序设计相关信息
1.实验题目：实验题6.4 假设n*n的稀疏矩阵A采用三元组表示，设计一个程序实现
如下功能：（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组。
| 1 0 3 1 |
| 0 1 0 0 |
| 0 0 1 0 |
| 0 0 1 1 |
2.实验项目组成：
（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组
3.实验项目的程序结构（程序中的函数调用关系图）：
4.实验项目包含的各个文件中的函数的功能描述：
CreatMat：对一个二维稀疏矩阵创建其三元组表示，以行序方式扫描二维稀疏矩阵A，将其非零的元素插入到三元组t中。
DispMat：输出三元组。
从头到尾扫描三元组t，依次输出元素值。
TranMat：矩阵转置。
对一个m*n的矩阵A m*n，其转置矩阵是一个n*m的矩阵，设为
B n*m，满足a i，j=b i，j，其中0≤i≤m-1，0≤j≤n-1。
5.算法描述或流程图：
6.实验数据和实验结果：
7.出现的问题及解决方案
主函数缺少一次输出，稀疏矩阵没有显示。
解决方案：主函数加一个输出稀疏矩阵disp（A）。
三、程序盘
提交的程序盘应包含全部的源程序清单和可执行文件。
稀疏矩阵实验报告
一、实验目的1. 理解稀疏矩阵的概念和特点。
2. 掌握稀疏矩阵的三元组表示方法。
3. 熟悉稀疏矩阵的基本运算，如转置、加法、减法等。
4. 提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 稀疏矩阵的三元组表示- 设计稀疏矩阵的三元组存储结构。
- 编写函数实现稀疏矩阵的三元组表示。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置。
- 实现稀疏矩阵的加法、减法。
- 实现稀疏矩阵的乘法。
3. 实验结果分析- 对实验结果进行分析，比较稀疏矩阵与普通矩阵运算的效率。
四、实验步骤1. 稀疏矩阵的三元组表示- 定义稀疏矩阵的三元组存储结构，包括行号、列号和元素值。
- 编写函数实现稀疏矩阵的三元组表示，包括读取稀疏矩阵的三元组数据、构建稀疏矩阵的三元组表示等。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置，包括交换行号和列号、重新排序等。
- 实现稀疏矩阵的加法、减法，包括遍历两个稀疏矩阵的三元组，计算对应元素的加法或减法结果。
- 实现稀疏矩阵的乘法，包括遍历两个稀疏矩阵的三元组，计算对应元素的乘法结果。
3. 实验结果分析- 对实验结果进行分析，比较稀疏矩阵与普通矩阵运算的效率。
- 分析实验结果，得出稀疏矩阵运算的优缺点。
五、实验结果1. 稀疏矩阵的三元组表示- 读取稀疏矩阵的三元组数据，构建稀疏矩阵的三元组表示。
2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置，包括交换行号和列号、重新排序等。
- 实现稀疏矩阵的加法、减法，包括遍历两个稀疏矩阵的三元组，计算对应元素的加法或减法结果。
- 实现稀疏矩阵的乘法，包括遍历两个稀疏矩阵的三元组，计算对应元素的乘法结果。
3. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高，尤其在稀疏程度较高的矩阵上。
- 稀疏矩阵运算的缺点是存储空间较大，且运算过程中需要频繁进行数据交换。
实现稀疏矩阵采用三元组表示的基本运算实验报告
实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（1）生成如下两个稀疏矩阵的三元组a 和 b；（上机实验指导 P92 ）（2）输出 a 转置矩阵的三元组；（3）输出a + b 的三元组；（4）输出 a * b 的三元组；三实验内容:3.1 稀疏矩阵的抽象数据类型:ADT SparseMatrix {数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;ai,j∈ElemSet,m 和n分别称为矩阵的行数和列数 }数据关系 : R={ Row , Col }Row ={<ai,j ,ai,j+1> | 1≤ i≤m , 1≤ j ≤ n-1}Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}基本操作:CreateSMatrix(&M)操作结果：创建稀疏矩阵M PrintSMatrix(M)初始条件：稀疏矩阵M已经存在操作结果：打印矩阵M DestroySMatrix(&M)初始条件：稀疏矩阵M已经存在操作结果：销毁矩阵M CopySMatrix(M, &T)初始条件：稀疏矩阵M已经存在操作结果：复制矩阵M到TAddSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的和Q=M+N SubSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件：稀疏矩阵M已经存在操作结果：求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件：稀疏矩阵M已经存在操作结果：求矩阵的积Q=M*N }ADT SparseMatrix3.2存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 //矩阵中非零元素最多个数typedef struct{ int r; //行号int c; //列号ElemType d; //元素值} TupNode; //三元组定义typedef struct{ int rows; //行数值int cols; //列数值int nums; //非零元素个数TupNode data[MaxSize];} TSMatrix; //三元组顺序表定义3.3基本操作实现:void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nu ms].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows ,t.cols,t.nums);printf("\t------------------\n ");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i] .r,t.data[i].c,t.data[i].d);3.4解题思路：1.转置矩阵：只要判定原矩阵有值，那么只要遍历一遍原矩阵，把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。
稀疏矩阵课程设计实验报告
数据结构课程设计学院：信息科学与工程学院专业：计算机科学与技术班级：计算机1108学号：学生姓名：指导教师：2013 年 3 月 10 日稀疏矩阵一、实验内容基本要求：1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、想减、相乘的运算。
2.稀疏矩阵的输入形式采用三元组表表示，而运算结果则以通常的阵列形式输出选作内容：1.按书中的描述方法，以十字链表表示稀疏矩阵2.增添矩阵求逆的运算，包括不可求逆的情况。
在求逆之前，先将稀疏矩阵的内容表示改为十字链表…二、数据结构设计三元组结构体定义如下：#include <stdio.h>#include <stdlib.h>#define MAX 100typedef struct{int i,j;int e;}Triple;struct juzhen{Triple data[MAX+1];int first[MAX+1];int mv,nv,tv;};十字链表结构定义如下#include<stdio.h>#include<stdlib.h>#include<conio.h>typedef int ElemType;typedef struct CLNode{int row ;int col;ElemType fenzi;ElemType fenmu;CLNode * right;CLNode * down;}CLNode;typedef struct{CLNode ** rhead;CLNode ** chead;int ru;int lu;int tu;}CrossList;三、算法设计1．三元组表构建稀疏矩阵的定义如下：ADT Matrix{数据对象：D={a ij|i=1,2,…,m; j=1,2,…,n;a ij∈ElemSet, m和n分别为矩阵的行数和列数}数据关系：R={Row,Col }Row={﹤a i,j, a i,j+1﹥| 1≤i≤m, 1≤j≤n-1}Col = {﹤a i,j, a i+1,j﹥| 1≤i≤m-1, 1≤j≤n}基本操作：ChuangJian (XiShu &M)操作结果：创建稀疏矩阵矩阵TMShuChu(XiShu Q)操作结果：通常形式输出稀疏矩阵AddMatrix(XiShu M,XiShu N,XiShu *Q)操作结果：稀疏矩阵的加法运算:void JianMatrix(XiShu M,XiShu N,XiShu *Q)操作结果：稀疏矩阵的减法运算void ChengMatrix(XiShu M,XiShu N,XiShu *Q)操作结果：稀疏矩阵的乘法运算}ADT Matrix;2 十字链表创建稀疏矩阵的定义如下:ADT SparseMatrix{数据对象 D={a ij|i=1,2,3……m,j=1,2,3……n;a ij属于ElemSet,m和n分别是稀疏矩阵的行数和列数}数据关系 R={ Row, Col }Row={<a ij,a ij+1>|1<=i<=m,1<=j<=n-1}Col={<a ij,a i+1j>|1<=i<=m-1,1<=j<=n}基本操作:void Input( CrossList &D )操作结果：十字链表创建稀疏矩阵int Determinant( const CrossList &D ,int row , int line )操作结果：求稀疏矩阵行列式的值void Reduction( int &fenzi, int &fenmu )操作结果：分子分母约分CrossList *InverseMatrix( const CrossList &D )操作结果：求稀疏矩阵的逆矩阵void Output( const CrossList *E )操作结果：十字邻接矩阵的输出}ADT SparseMatrix3.1 功能模块图本功能分为四个模块3.2 算法思路3.2.1实现方法列出系统中的所有函数并说明函数的功能void main() //三元组表法和十字链表的主函数int ChuangJian(XiShu *M) //三元组表法创建稀疏矩阵void ShuChu(XiShu Q) //三元组表法输出稀疏矩阵void AddMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相加功能void JianMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相减功能void ChengMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相乘功能int Determinant(CrossList &D ,int row ,int line )//行列式求值void Reduction( int &fenzi, int &fenmu ) //分子分母约分void Input( CrossList &D ) //十字链表输入函数CrossList *InverseMatrix(CrossList &D)//求稀疏矩阵的逆矩阵void Output( const CrossList *E ) //十字链表输出函数3.2.2 设计思想稀疏矩阵加法运算思路:首先判断两个矩阵行数列数是否相等，比较两个矩阵中不为0的元素的行数i 及列数j，将i与j都相等的前后两个元素值e相加，保持i,j不变储存在新的三元组中，不等的则分别储存在此新三元组中稀疏矩阵减法运算思路:将后一个矩阵的每一个非零元都乘以-1，再调用加法运算的函数稀疏矩阵乘法运算思路:逐个定位两个矩阵的非零元的位置，从第一个矩阵的第一行开始，再从第二个矩阵的第一列开始，找到非零元相乘相加，并利用累加器逐列累加稀疏矩阵求逆运算的思路:矩阵的逆等于矩阵的伴随矩阵除以矩阵行列式的值（1）定义全局变量#define MAX 100#define TRUE 1#define FAULT 0typedef int ElemType;（2）主函数模块说明主函数主要结构void main( ){ 初始化；Switch（）{Case :接受命令；选择处理命令}不满足退出}void main( ){初始化；接受命令；选择处理命令}（3）其他模块说明（用文字描述，不要代码）int CreateSMatrix(TSMatrix *M){初始化；输入行数、列数、非零元个数for(){for()按行为主序输入每一个非零元赋值}返回结果}void PrintSMatrix(TSMatrix Q){两层for循环输出每一个非零元}void AddRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){判断行数、列数是否对应相等，若均相等则相加并赋值否则依次判断行数、列数的大小并再次判断将值放在另一个数组里}Void JianRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){两层for循环将第二个矩阵的每一个非零元变为他的负数再调用相加函数}void MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){初始化判断第一个矩阵的行数时候等于第二个矩阵的列数然后逐个定位两个矩阵的非零元的位置，从第一个矩阵的第一行开始，再从第二个矩阵的第一列开始，找到非零元相乘相加，并利用累加器逐列累加}四、测试数据及程序运行情况三元组表实现加法运算三元组表实现乘法运算十字链表实现求逆运算五、实验过程中出现的问题及解决方案1）问题：运行过程中发现加法减法能正常运行，而乘法却在计算时出现问题。
数据结构三元组稀疏矩阵
一、课程设计的目的1.将C++语言理论基础实例化。
2.掌握关于编程的技巧和方法。
3.培养解决综合性实际问题的能力。
二、课程设计任务题目：稀疏矩阵A，B的和题目要求：稀疏矩阵A,B用三元组顺序表存储。
三元组表C存放结果矩阵A，B的和存到C中。
题目：用三元组C存放以三元组顺序表做存储结构的稀疏矩阵A，B的和一、题目分析三元组表C是结果矩阵，其中元素仍行优先排列，按元素的行列去找A中的三元组，若有，则加入C，同时，这个元素如果在B中也有，则加上B的这个元素值，否则这个值就不变;如果A中没有，则找B，有则插入C，无则查找下一个矩阵元素。
两个稀疏矩阵的非零元素按三元组表形式存放，二、程序代码#include<iostream.h>#include <malloc.h>#define max 10typedef struct{int i,j;int v;}spnode;typedef struct{int mu,nu,tu;spnode data[max];}spmatrix;addmatrix(spmatrix *a,spmatrix *b){spmatrix *c;int p=0;q=0;col;c=(spmatrix*)malloc(sizeof(spmatrix));c->mu=a->mu;c->nu=a->nu;c->tu=0;while (p<a->tu&&q<b->tu){if((a-> data[p].i==B-> data[q].i)&&(A-> data[p].j==B-> data[q].j)) { col=a-> data[p].v+B-> data[q].v;if(col!=0){ c-> data[c-> tu].i=a-> data[p].i;c-> data[c-> tu].j=a-> data[p].j;c-> data[c-> tu++].v=col;}p++;q++;}if ((a-> data[p].i==b-> data[q].i)&&(a-> data[k].j <b-> data[l].j)){ c-> data[c-> tu].i=a-> data[p].i;c-> data[c-> tu].j=a-> data[p].j;c-> data[c-> tu++].v=a-> data[p].v;p++;}if ((a-> data[p].i==b-> data[q].i)&&(a-> data[k].j >b-> data[l].j)){ c-> data[c-> tu].i=a-> data[p].i;c-> data[c-> tu].j=a-> data[p].j;c-> data[c-> tu++].v=a-> data[p].v;q++;}}while (p<a->tu){ c-> data[c-> tu].i=a-> data[p].i;c-> data[c-> tu].j=a-> data[p].j;c-> data[c-> tu++].v=a-> data[p].v;p++;}while(q<b->tu){ c-> data[c-> tu].i=b-> data[q].i;c-> data[c-> tu].j=b-> data[q].j;c-> data[c-> tu++].v=b-> data[q].v;q++;}}void Setmatrix(SPMatrix* p){int n;cout<<"请输入矩阵行数、列数及非0元个数"<<endl;cin>>p->mu>>P->nu>>p->tu;cout<<"三元组表"<<endl;for(n=1;n<=p->tu;n++)cin>>p->data[n].i>>p->data[n].j>>p->data[n].v;}void main(){spmatrix a;spmatrix b;int i,j,k = 1;spmatrix *c;Setmatrix(&a);Setmatrix(&b);c = addmatrix(&a,&b);cout<<"三元组表c"<<endl;for (i = 1; i <= c->mu; ++i){for (j = 1;j <= c->nu ; ++j){if (pc->data[k].i == i && pc->data[k].j == j){ cout<<i<<j<<c->data[k].v);k++;}}}free(c);}三、运行结果四、总结三元组存储的矩阵的加法关键在于算法的分析。
实验七 稀疏矩阵
实验报告七稀疏矩阵操作实验
班级：姓名：学号：专业：
一、实验目的：
1、了解多维数组的存储方式和存取特点
2、熟悉稀疏矩阵的存储方式
3、用三元组法实现稀疏矩阵的相、减、转置算法。
二、实验内容：（请采用模板类及模板函数实现）
1、稀疏矩阵三元组存储表示及基本操作算法实现
[实现提示] （同时可参见教材p130-p133页算法）函数、类名称等可自定义，部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义及类的定义：
（1）稀疏矩阵的三元组顺序存储结构类定义：
自定义如下：
（2）构造稀疏矩阵算法;（输入参数自定义）
（3）打印稀疏矩阵算法;
(4)两稀疏矩阵相加，获得一新的矩阵的算法;（自行设计）
初始条件：稀疏矩阵M与N的行数和列数对应相等
(5)两稀疏矩阵相减，获得一新的矩阵的算法;（自行设计）
初始条件：稀疏矩阵M与N的行数和列数对应相等
(6)求稀疏矩阵M的转置矩阵T算法;
初始条件：M存在。
测试结果如下：
选做题：
1、实现多维数组的顺序存储表示和操作算法。
（操作函数自定义，可参见课件）
2、参考p134页，实现稀疏矩阵十字链表存储类定义和创建操作算法。
三、实验心得（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的
心得）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
四、系统实现................................................................................................................ 6 4.1 主调函数.......................................................................................................... 6 4.2 三元组表的建立.............................................................................................. 6 4.3 矩阵的建立...................................................................................................... 7 4.4 矩阵相加减及转置........................................................................................ 10
数据结构课程设计 本课程设计已调试通过，请放心使用。请到：道客巴 巴或豆丁网充值购买 word 版，省存结构实现稀疏矩阵操 作_课程设计_实验报告
设计题目：基于三元组表的储存结构实现稀疏矩阵操作
课题名称 院系 学号
本模块要求设计函数进行稀疏矩阵的转置并输出转置后的结果。在编写函 数时，要先定义一个相应的结构体变量用于存放转置后的矩阵，最后把函数进行两稀疏矩阵相加、减及相乘并输出最终稀疏矩阵
本模块要求设计相加、减和相乘函数对两个矩阵进行运算，并输出最终的稀疏 矩阵，定义相应的矩阵类型用于存放两个矩阵操作后的结果矩阵，这个结果矩阵 的行、列数需要综合多方面情况来确定。这些函数也是整个程序的难点，需要灵 活运用数组及指针的特点。
020
003
003
定义两个数组 A 和 B，用于存储矩阵 a 和矩阵 b 的值；定义一个数组 C，用于存
放数组 A 和数组 B 相加后的结果。
2） 实现方式 稀疏矩阵的存储比较浪费空间，所以我们可以定义两个数组 A、B，
采用压缩存储的方式来对上面的两个矩阵进行存储。具体的方法是，将非零元素
的值和它所在的行号、列号作为一个结点存放在一起，这就唯一确定一个非零元
基于三元组表的储存结构实现稀疏矩阵的基本操作
姓名
年级专业 成绩
1、课题设计目的：其目的是让我们在学习完 C、数据结构等课 程基础上，掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的 压缩存储及转置，相加，相减等基本操作，并用不同的方法输出结 果，进一步掌握设计、实现较大系统的完整过程，包括系统分析、 编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、 设计、实现以及操作方法，为进一步的应用开发打好基础。 课题设计
三、项目设计................................................................................................................ 2 3.1 设计思路及方案............................................................................................. 2 3.11 设计思路........................................................................................................ 2 3.2 模块图.............................................................................................................. 4 3.3 流程图............................................................................................................. 5
六、实验总结.............................................................................................................. 18 七、附录...................................................................................................................... 18
2.4 退出系统
本模块要求设置选项能随时结束程序的运行，本程序中采用 do-while 循 环。程序在计算机上显示“提示信息”之后，由用户在键盘上输入演示程序中需 要的相关信息及命令。
三、项目设计
3.1 设计思路及方案
3.11 设计思路
1） 主界面的设计
定义两个矩阵 a= 1 0 0
b=1 0 4
023
7.1 参考文献......................................................................................................... 18
一、实验目的及意义
1.1 实验目的 1.11 了解多维数组存储方式和存储特点。 1.12 熟悉稀疏矩阵的存储方式。 1.13 用三元组法实现稀疏矩阵的转置、相加、相减的操作。
五、系统调试.............................................................................................................. 15 5.1 系统输入........................................................................................................ 15 5.2 矩阵转置........................................................................................................ 16 5.4 矩阵相减........................................................................................................ 17
2
素的三元组（i、j、v）。将表示稀疏矩阵的非零元素的三元组按行优先的顺序排 列，则得到一个其结点均为三元组的线性表。即：以一维数组顺序存放非零元素 的行号、列号和数值，行号-1 作为结束标志。例如，上面的矩阵 a，利用数组 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 同理，用数组 B 存储 矩阵 b 的值。 稀疏矩阵的加法实现： 3、主要算法结构分析： 1)void CreateMatrix(int A[m][n],int B[50]),这是一个将稀疏矩阵转存的函数，类似于顺序存储三元组 表。在这个方法中，只要用一个二重循环来判断每个矩阵元素是否为零，若不为 零，则将其行、列下标及其值存入到一维数组 B 中对应的元素。在定义函数的过 程中，我们需要定义一个 for 循环，以完成行和列的转换及存储。在函数的末尾 我们定义一个 B[K]=-1，用于结束非零元素的存储。 2)void MatrixAdd(int A[max],int B[max],int C[max]),这个函数用于实现数组 A 和数组 B 的相加，并 将其相加的结果存入数组 C。这个函数讨论了数组在相加的过程中的几种情况： a、A 数组和 B 数组的行相等且列相等，两者直接相加后存入数组 C 中。
1.2 实验意义 空非零元素分布没有规律，在存储非零元素的同时还要存储辅助信息，才能
确定非零元素的位置，利用稀疏矩阵大大节省存储空间。
二、需求分析
2.1 设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值 本模块要求设计函数建立稀疏矩阵并初始化，包括在三元组结构下和
十字链表结构下。在创建稀疏矩阵时，需要设计两个不同的函数分别在三元组和 十字链表下创建稀疏矩阵，在输入出现错误时，能够对错误进行判别处理，初始 化稀疏矩阵都为空值。在设计输出稀疏矩阵的值的函数时，也要针对两种不同的 情况，分别编制函数，才能准确的输出稀疏矩阵。在对稀疏矩阵进行初始化时， 只输入非零元素的值和它所在的所在行及所在列。在对稀疏矩阵输出时，以矩阵 的完整形式输出。 2.2 构造函数进行稀疏矩阵的转置并输出结果