稀疏矩阵的建立与转置(优选.)
稀疏矩阵三元组快速转置(转poklau123写的很清楚)

稀疏矩阵三元组快速转置(转poklau123写的很清楚)关于稀疏矩阵的快速转置法,⾸先得明⽩其是通过对三元表进⾏转置。
如果误以为是对矩阵进⾏转置,毫⽆疑问就算你想破脑袋也想不出个所以然,别陷⼊死胡同了!对于⼀个三元表,⾏为i,列为j,值为v。
需将其i与j的值对调才能得到新的三元表,但是如果直接进⾏转换,得到的新的三元表的顺序是混乱的,不符合三元表的规则。
所以,课本⾸先介绍了⼀个⽤扫描来转置的算法(这个算法⽐较容易,在这⾥我就不说了),但是这个转置算法的时间复杂度太⾼,于是就有了接下来的快速转置算法。
要你对⼀个三元表进⾏步骤最少的转置,你可能会想,如果知道三元表中每⼀项在转置后的新的三元表中的位置,然后直接放进去,岂不是极⼤的缩⼩了时间复杂度?没错!快速转置法正是基于这种思想⽽设计的。
那么如何知道三元表中某⼀项的位置呢?在课本98页的a.data这个三元表可以看到,j为列号,在转置后即为新的三元表的⾏号,三元表正是按照⾏序进⾏排列的,⽽j=1有2个、j=2有2个、j=3有2个、j=4有1个、j=6有1个。
根据这些数据按照从⼩到⼤排列,j=1的项在新的三元表中应占据第1、2位,j=2的项在新的三元表中应占据第3、4位,j=3的项在新的三元表中应占据第5、6位,j=4应占据第7位,j=6应占据第8位。
接下来就轻松多了,转置的时候直接从第⼀项读起,读取其j值,⽐如课本中a.data这个三元表的第⼀项的j值为2,因为j=2占据第3、4位,所以应该从第三位开始放,接下来如果读取的某⼀项的j值也是2,就放在第4位。
因为j=2的项只有两个,所以第5位绝对不会被j=2的项占据,第5、6项本来就是留给j=3的。
再⽐如当读到j=6的那项时,第8位是留给它的,就可以直接放进第8位了。
这样,读取每⼀项,都能在三元表中找到相应的位置,这就是稀疏矩阵快速转置的原理。
当然,上⾯只是快速转置的原理,要实现它,就要设计算法来实现了。
稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点2.2 三元组顺序表的数据结构和实现方式2.3 存储表示的优缺点分析3. 稀疏矩阵转置算法3.1 转置操作的意义与应用场景3.2 基于三元组顺序表的转置算法设计思路3.3 转置算法的具体实现步骤与复杂度分析4. 实验与结果分析4.1 实验设置和数据样本介绍4.2 转置算法在不同稀疏矩阵上的性能评估和结果比较4.3 分析结果及启示与讨论5. 结论与展望5.1 结论总结5.2 存在问题及后续工作展望1. 引言1.1 背景和意义稀疏矩阵是一种在实际问题中经常遇到的特殊矩阵结构,其绝大部分元素为零。
与稠密矩阵相比,稀疏矩阵的存储和计算效率更高。
稀疏矩阵可以应用于图像处理、网络分析、线性代数等领域。
三元组顺序表是一种存储稀疏矩阵的数据结构,通过记录非零元素的行索引、列索引和数值,有效地减少了存储空间。
同时,三元组顺序表也提供了便捷的转置操作方式。
因此,深入掌握稀疏矩阵的三元组顺序表存储表示及其转置算法对于提高稀疏矩阵相关问题的解决效率具有重要意义。
1.2 结构概述本文将从两个方面进行论述。
首先,介绍稀疏矩阵的定义与特点,以及三元组顺序表在存储表示中所采用的数据结构和实现方式。
其次,详细描述了基于三元组顺序表的稀疏矩阵转置算法的设计思路、具体实现步骤和复杂度分析。
1.3 目的本文旨在探究稀疏矩阵的三元组顺序表存储表示及其转置算法,在理论层面上深入分析其原理和优劣,并在实验中验证其性能表现。
通过本文的研究,我们希望能够提供一种高效、灵活且易于实现的方法来处理稀疏矩阵,并为进一步的相关应用提供有价值的启示和参考。
2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点稀疏矩阵是指在一个二维矩阵中,大部分元素都为0的情况下,只有少数非零元素的情况。
数据结构实验2稀疏矩阵的建立与转置

实验2 稀疏矩阵的建立与转置(一)实验目的掌握特殊矩阵的存储和操作算法。
(二)问题描述实现用三元组保存稀疏矩阵并实现矩阵转置的算法。
(三)实验步骤1. 定义稀疏矩阵的三元组形式的存储结构。
2. 实现三元组矩阵的传统转置算法(pp99 的算法5.1)。
3. 实现三元组矩阵的快速转置算法。
4. 输入矩阵非零元素,测试自己完成的算法。
(四)程序流程图(五)参考代码#include <malloc.h>#include <stdio.h>#define MAXLEN 40typedef struct{ int i, j;int v;}NODE;typedef struct{ int m, n, t;NODE data[MAXLEN];}SPMA TRIX;SPMA TRIX transpose(SPMA TRIX a){/*稀疏矩阵(三元组存储结构)转置算法*/int p, q, col;SPMA TRIX b;b.m=a.n; b.n=a.m; b.t=a.t;if(a.t!=0){q = 1;for (col=1; col<=a.n; col++) //访问b三元组的每一行for (p=1; p<=a.t; p++) //访问a三元组的每一行if(a.data[p].j==col) //如果b三元组的行对应a数组的列,就进行转置{ b.data[q].j=a.data[p].i;b.data[q].i=a.data[p].j;b.data[q].v=a.data[p].v;q++;}}return b;}void printmatrix(SPMA TRIX c){/*稀疏矩阵(三元组存储结构)显示*/int n,i;n=c.t;for(i=1;i<=n;i++)printf("[%d]行号=%d 列号=%d 元素值=%d\n",i,c.data[i].i,c.data[i].j,c.data[i].v);}void main(){ SPMA TRIX a;SPMA TRIX b;int i,j,r,c,t,n;n=1;printf("\n\n输入矩阵行号数: ");scanf("%d",&r);printf("\n\n输入矩阵列号数: ");scanf("%d",&c);a.m=r; a.n=c;printf("\n\n");for(i=0;i<r;i++) /*输入矩阵元素值*/for(j=0;j<c;j++){printf("输入元素[%d,%d]值: ",i+1,j+1);scanf("%d",&t);if(t!=0) {a.data[n].i=i+1; /*非零元素存入稀疏矩阵三元组存储结构中*/a.data[n].j=j+1; a.data[n].v=t; n=n+1;}}n=n-1; a.t=n; /*a.t中为稀疏矩阵非零元素个数*/printf("\n\n稀疏矩阵三元组表示: \n\n");printmatrix(a); /*稀疏矩阵(三元组存储结构)转置*/b=transpose(a);printf("\n\n转置后稀疏矩阵三元组表示: \n\n");printmatrix(b);printf("\n\n");}(六)运行结果(七)心得体会掌握了特殊矩阵的存储和操作原理,编写了用三元组保存稀疏矩阵并实现矩阵转置的算法。
稀疏矩阵的表示和转置

实验2稀疏矩阵的表示和转置实验人:杜国胜学号:Xb14680103时间:11.91、实验目的1.掌握稀疏矩阵的三元组顺序表存储结构2.掌握稀疏矩阵的转置算法。
2、实验内容采用三元组表存储表示,求稀疏矩阵M的转置矩阵T。
(算法5.1)3、实验步骤:1.构建稀疏矩阵M。
2.求稀疏矩阵M的转置矩阵T。
3.输出稀疏矩阵M和稀疏矩阵T。
4、算法说明首先要创建稀疏矩阵和三元组顺序表,定义mu,mu,tu分别表示矩阵的行列数和非零元个数。
在进行稀疏矩阵的转置时要做到1.将矩阵的行列值相互交换2.将每个三元组的I,j相互调换3.重排三元组之间的次序5、测试结果6、分析讨论在此次程序中转置的方法称为快速转置,在转置前,应先求的M的每一列中非零元的个数,进而求得每一列的第一个非零元的位置7、附录:源代码#include<stdio.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}TSMatrix;//创建稀疏矩阵Mvoid CreateSMatrix (TSMatrix *M){int i,m,n,e,k;printf("输入矩阵M的行数、列数、非零元的个数(中间用逗号隔开):");scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);(*M).data[0].i=0;printf("\n");for(i=1;i<=(*M).tu;i++){do{printf("输入第%d个非零元素所在的行(1~%d)列(1~%d)值以及该数值:",i,(*M).mu,(*M).nu);scanf("%d,%d,%d",&m,&n,&e);k=0;if(m<1||m>(*M).mu||n<1||n>(*M).nu)k=1;if(m<(*M).data[i-1].i||m==(*M).data[i-1].i&&n<(*M).data[i-1].j)k=1;}while(k);(*M).data[i].i=m;(*M).data[i].j=n;(*M).data[i].e=e;}printf("\n");}//输出稀疏矩阵Mvoid PrintSMatrix(TSMatrix M){int i;printf("**************************************\n");for(i=1;i<=M.tu;i++)printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e); printf("**************************************\n");printf("\n");}//求稀疏矩阵M的转置矩阵Tvoid TransposeSMatrix(TSMatrix M,TSMatrix *T){int p,q,col;(*T).mu=M.nu;(*T).nu=M.mu;(*T).tu=M.tu;if((*T).tu){q=1;for(col=1;col<=M.nu;++col)for(p=1;p<=M.tu;++p)if(M.data[p].j==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;++q;}}}void print(TSMatrix A){int k=1,a,b;int M[MAXSIZE][MAXSIZE];printf("非零元素所对应的位置:\n");printf("**************************************\n"); for(a=0;a<A.mu;a++){for(b=0;b<A.nu;b++)M[a][b]=0;}while(k<=A.tu){M[A.data[k].i-1][A.data[k].j-1]=A.data[k].e;k++;}for(a=0;a<A.mu;a++){printf(" | ");for(b=0;b<A.nu;b++)printf("%d ",M[a][b]);printf(" | \n");}printf("**************************************\n"); printf("\n");}//主函数int main(){TSMatrix M,T;printf("创建矩阵M:");CreateSMatrix(&M);printf("矩阵M的三元组表为:\n");PrintSMatrix(M);print(M);TransposeSMatrix(M,&T);printf("稀疏矩阵M的转换矩阵T的三元组表为:\n");PrintSMatrix(T);print(T);printf("\n\n");getchar();return 0;}。
稀疏矩阵的快速转置算法

稀疏矩阵的快速转置算法
稀疏矩阵的快速转置算法可以使用压缩存储的方式来实现。
稀疏矩阵通常包含很多零元素,因此压缩存储可以极大地减少存储空间和计算时间。
压缩存储可以使用两个数组来表示稀疏矩阵,一个存储非零元素的值,另一个存储非零元素在原始矩阵中的行列索引。
假设原始矩阵的行数为m,列数为n,稀疏矩阵中非零元素的个数为k。
转置算法的步骤如下:
1. 创建一个新的稀疏矩阵,行数为n,列数为m,非零元素个数为k。
2. 初始化一个长度为n的数组col_ptr,用于记录每列的第一个非零元素在转置矩阵中的索引。
3. 通过遍历原始稀疏矩阵的每个非零元素,将其值存储到转置矩阵的非零元素数组中,并根据其列索引更新col_ptr数组。
4. 根据col_ptr数组,计算每列非零元素在转置矩阵非零元素数组中的起始位置,并将其存储到col_ptr数组中。
5. 返回转置矩阵。
这个算法的时间复杂度为O(k),空间复杂度为O(n+m+k)。
通过压缩存储和利用非零元素在矩阵中的位置信息,这种算法可以高效地实现稀疏矩阵的快速转置。
稀疏矩阵的相关操作

稀疏矩阵的相关操作稀疏矩阵是指在一个矩阵中,大部分元素为0的矩阵。
由于大部分元素为0,而非零元素相对较少,稀疏矩阵的存储和处理具有一定的特殊性。
在实际应用中,经常需要对稀疏矩阵进行各种操作,如创建、存储、加法操作等。
本文将从这些方面详细介绍稀疏矩阵的相关操作。
首先,创建稀疏矩阵需要考虑两个关键因素:矩阵的大小和矩阵的稀疏性。
对于稀疏矩阵的大小,一般可以使用行数和列数来描述。
而对于稀疏矩阵的稀疏性,可以使用一个矩阵的非零元素个数与总元素个数的比值来衡量,一般使用稀疏度来表示,即非零元素个数与总元素个数的比值。
创建稀疏矩阵的方法有多种,下面介绍两种常见的方法。
1.压缩矩阵存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个矩阵中。
其中,矩阵的每一行存储一个非零元素的值、行和列坐标。
这种方法虽然节约了存储空间,但是在进行矩阵操作时,需要通过遍历矩阵找到对应的非零元素,因此操作效率较低。
2.链表存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个链表中。
链表的每个节点包含一个非零元素的值、行和列坐标,以及下一个非零元素的指针。
这种方法在插入和删除操作时比较方便,并且节约了存储空间。
但是,链表存储法在进行矩阵操作时,也需要通过遍历链表找到对应的非零元素,因此操作效率较低。
除了创建稀疏矩阵,还需要进行其他各种操作,如稀疏矩阵的加法、乘法、转置等。
稀疏矩阵的乘法操作较为复杂。
对于两个稀疏矩阵相乘,需要根据矩阵乘法的定义,将一个矩阵的行与另一个矩阵的列进行乘法运算,然后将结果相加得到最终的乘积矩阵。
由于稀疏矩阵的特殊性,可以采用稀疏矩阵乘法算法进行计算,提高乘法操作的效率。
1.三元组转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在三个数组中,分别是非零元素数组、行坐标数组和列坐标数组。
将这三个数组的元素进行转置,并重新组合成转置后的稀疏矩阵。
2.链表转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在链表中。
稀疏矩阵三元组实现矩阵转置算法实验报告

稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一.实习目的1.掌握稀疏矩阵的三元组顺序表存储表示;2.掌握稀疏矩阵三元组表示的传统转置算法的实现;3.掌握稀疏矩阵三元组表示的快速转置算法的实现;二.实习内容1.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现传统转置算法,输出按通常的阵列形式输出。
2.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现快速转置算法,输出按通常的阵列形式输出。
三.实验步骤1.三元组的定义#define MAX_SIZE 100 // 非零元个数的最大值struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};2.创建稀疏矩阵M (按三元组形式输入,即按行序输入非零元的行号、列号、值)3. 编写三元组传统转置函数。
4. 编写三元组快速转置函数。
4. .主函数(1)程序代码#include "stdio.h"#include "stdlib.h"#define MAX_SIZE 100 // 非零元个数的最大值typedef int ElemType;struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};int CreateSMatrix(TSMatrix &M){ // 创建稀疏矩阵Mint i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素数:");scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);if(M.tu>MAX_SIZE)return -1;M.data[0].i=0; // 为以下比较顺序做准备for(i=1;i<=M.tu;i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,M.mu,M.nu);scanf("%d,%d,%d",&m,&n,&e);//输入非零元的行号、列号、元素值k=0;if(m<1||m>M.mu||n<1||n>M.nu)// 行或列超出范围k=1;if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.d ata[i-1].j) // 行或列的顺序有错k=1;}while(k);M.data[i].i =m; // 将m,n,e 填入MM.data[i].j =n;M.data[i].e =e;}return 1;}void PrintSMatrix(TSMatrix M){ // 按矩阵形式输出Mint i,j,k=1;Triple *p=M.data;p++; // p指向第1个非零元素for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++)if(k<=M.tu&&p->i==i&&p->j==j)// p指向非零元,且p所指元素为当前处理元素{printf("%3d",p->e); // 输出p所指元素的值p++; // p指向下一个元素k++; // 计数器+1}else // p所指元素不是当前处理元素printf("%3d",0); // 输出0printf("\n");}}void TransposeSMatrix(TSMatrix M,TSMatrix &T){ // 求稀疏矩阵M的转置矩阵T。
稀疏矩阵转置算法的实现

稀疏矩阵转置算法的实现稀疏矩阵转置算法是一种十分重要的算法,它可以将一个大型的稀疏矩阵转换成另一个表述形式便于计算和存储。
在本文中,我们将讨论如何实现这样的算法。
首先,我们需要了解稀疏矩阵是什么。
稀疏矩阵是指在某种意义下,其中大多数值都为零的矩阵。
在实际应用中,这种矩阵十分常见。
由于其中大多数值都为零,因此,我们可以省略这些零值,只存储非零值。
这样,矩阵的存储空间就可以被大大减小。
那么,稀疏矩阵转置算法是什么?我们可以将转置矩阵定义为:把矩阵A的行换成列,列换成行所得到的矩阵。
在这个过程中,非零元素的位置会相应发生变化。
因此,在转置后的矩阵中,每个非零元素的行和列会互换。
接下来,我们来讨论一下稀疏矩阵转置算法的实现。
在实际应用中,我们通常使用三元组格式存储稀疏矩阵,即以行、列和非零元素为基本元素进行存储。
对于一个$m*n$的稀疏矩阵A,我们可以用一个数组A[0...t]来存储其中的非零元素。
数组中的每个元素包含三个值:行号i,列号j以及该位置上的数据A(i,j)。
其中,t表示非零元素的个数。
那么,如何实现矩阵的转置呢?算法的基本思路是:首先,我们需要遍历稀疏矩阵A中所有的元素,找到其中的每个非零元素;其次,我们将该非零元素从A中删除,并将它添加到新的稀疏矩阵B中。
在添加的过程中,我们需要将该元素的行和列互换,以满足转置的要求。
下面,我们来看一下矩阵转置算法的具体实现。
为了简洁起见,我们假设我们已经将稀疏矩阵A存储在三元组格式中,并且已经初始化了新的稀疏矩阵B。
具体实现如下:```for(k=0; k<t; k++){ // 遍历稀疏矩阵A中的所有元素i=A[k].row; // 获取当前元素的行j=A[k].col; // 获取当前元素的列x=A[k].value; // 获取当前元素的值B[k].row=j; // 将当前元素的行赋值为列B[k].col=i; // 将当前元素的列赋值为行B[k].value=x; // 将当前元素的值保持不变}```在这段代码中,我们首先使用for循环遍历了数组A中的所有元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验2 稀疏矩阵的建立与转置
一、实验目的
掌握特殊矩阵的存储和操作算法。
二、实验内容及问题描述
实现用三元组保存稀疏矩阵并实现矩阵转置的算法。
三、实验步骤
1. 定义稀疏矩阵的三元组形式的存储结构。
2. 实现三元组矩阵的传统转置算法。
3. 实现三元组矩阵的快速转置算法。
4. 输入矩阵非零元素,测试自己完成的算法。
四、程序流程图
五、概要设计
矩阵是很多的科学与工程计算中研究的数学对象。
在此,我们感兴趣的是,从数学结构这门学科着眼,如何存储矩阵的元从而使矩阵的各种运算有效的进行。
本来,用二维数组存储矩阵,在逻辑上意义是很明确的,也很容易理解,操作也很容易和方便。
但是在数值分析中经常出现一些阶数很高的矩阵,同时,在矩阵中又有很多值相同或者都为零的元素,可以对这种矩阵进行压缩存储:对多个值相同的元素只分配一个存储空间;对零元素不分配空间。
稀疏矩阵的定义是一个模糊的定义:即非零元个数较零元个数较少的矩阵。
例如下图所示的矩阵
为一个稀疏矩阵。
为了实现稀疏矩阵的这种存储结构,引入三元组这种数据结构。
三元组的线性表顺存储形式如下图:
六、详细设计
sanyuanzu.h 头文件
#define max 100
typedef struct
{
int row,col;
int e;
}Triple;//定义三元组
typedef struct
{
Triple data[max];
int mu,nu,tu;
}TSMatrix;///*定义三元组的稀疏矩阵*/
void creat( TSMatrix &M) ;
void fasttrans(TSMatrix A,TSMatrix &B);
void printfx(TSMatrix x);
sanyuanzu.cpp 文件
#include<stdio.h>
#include"sanyuanzu.h"
/*建立三元组的稀疏矩阵*/
void creat( TSMatrix &M)
{
printf("请输入稀疏矩阵的行数:");
scanf("%d",&M.mu);
printf("请输入稀疏矩阵的列数:");
scanf("%d",&M.nu);
printf("请输入矩阵中非零元素的个数:");
scanf("%d",&M.tu);
int i;
printf("请输入这%d 个元素的行号和列号及其元素的值:/n",M.tu);
for(i = 1; i <= M.tu;
i++)scanf("%d %d %d",&M.data[i].row,&M.data[i].col,&M.data[i].e);
}
/*实现三元组的矩阵转置的函数*/
void fasttrans(TSMatrix A,TSMatrix &B)
{
int col,cpot[max],num[max],t,p,q;
/*初始化矩阵B*/
B.mu=A.nu;
B.nu=A.mu;
B.tu=A.tu;
if(B.tu)
{
for(col=1;col<=A.nu;++col)
num[col]=0;/*初始化每一列非零元的个数*/
for(t=1;t<=A.tu;++t)
++num[A.data[t].col];/*计算每一列非零元的个数*/
cpot[1]=1;
for(col=2;col<=A.nu;++col)
cpot[col]=cpot[col-1]+num[col-1];//计算矩阵A 每一列第一个非零元在B.data 中的位置
/*实现对A 中的每一个非零元进行转置*/
for(p=1;p<=A.tu;++p)
{
col=A.data[p].col;
q=cpot[col];
B.data[q].row=A.data[p].col;
B.data[q].col=A.data[p].row;
B.data[q].e=A.data[p].e;
++cpot[col];
}
}
}
/*稀疏矩阵的输出*/
void printfx(TSMatrix x)
{
int i,j;
for(j=1;j<=x.tu;j++)
{
for(i=1;i<=x.mu;i++)
if(x.data[j].row==i)printf("%d %d %d/n",x.data[j].row,x.data[j].col,x.data[j].e );
}
}
main.cpp 文件
#include<stdio.h>
#include'"sanyuanzu.cpp"
//主函数
int main(void)
{
TSMatrix t,s;
creat(t);
printf("你所输入的稀疏矩阵为:/n");
printfx(t);
fasttrans(t,s);
printf("转置后的稀疏矩阵为:/n");
printfx(s);
return 0;
}
}
七、调试报告
八、分析与遇到的问题
(1)创建稀疏矩阵时,不懂如何用三元组表示元素的输出;
(2)需要注意矩阵运算中的特殊状况,
稀疏矩阵相加时,忘记对应元素相加为0时,在稀疏矩阵中不表示;
(3)矩阵相加时,第一个矩阵的行列数要和第二个矩阵的行列数相等;
(4)输出矩阵时,输出界面不整齐。
九、用户使用说明
(1)运行程序,首先会看到一个提供选择的界面,输入相应的序号实现相应的功能;
(2)在进行相应的功能之后按提示要求一三元组形式输入相应矩阵。
(注意:每个数据之间用空格隔开);
(3)输入相应矩阵之后会输出最后的运算结果;
(4)输出结果运算之后会可按任意键返回。
十、心得体会
这次数据结构课程设计的制作使我对数据结构和C语言的理解加深,也使我自己认识到自己很多不足之处。
我发现自己再处理稍微具体的程序时显得无从下手以前学习的知识只是理论性的知识,并没有真正实践过,当我通过网上查询、复习知识后才对编程程序有了初步思路。
后来编写程序时也碰到了许多错误,我对于指针的掌握程度较差导致我再使用时产生了很多错误请教了老师和同学才逐步完成。
这次实验使我认识到要想做成一个完整的程序绝对不是简单的事。
我明白了无论是是做什么我们搜必须按部就班的从点滴做起,逐步完成。
最新文件---------------- 仅供参考--------------------已改成-----------word文本--------------------- 方便更改。