稀疏矩阵三元组存储转置后矩阵输出
稀疏矩阵三元组快速转置(转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. 三元组表的行数应为非零元素的个数加一,列数固定为3。
2. 需要按照行优先的顺序输出非零元素的行、列和数值。
3. 输出完所有的非零元素后,需要在三元组表的最后一行输出稀疏矩阵的行数、列数和非零元素的个数。
4. 三元组表的输出格式可以根据需要进行调整,可以使用空格或制表符进行分隔,也可以使用换行符进行换行。
在实际应用中,三元组表的输出结果往往需要进行存储或传输,因此需要考虑输出结果的压缩和解压缩。
其中,压缩方法包括利用行压缩法和列压缩法对三元组表进行压缩,以减小存储空间;解压缩方法则是将压缩后的数据进行还原,还原成原始的三元组表。
总之,输出稀疏矩阵的三元组表是一种重要的数据结构,能够大大提高稀疏矩阵的存储效率和计算效率。
在实际应用中,需要根据具体情况选择合适的输出格式和压缩方法,以达到最优的效果。
- 1 -。
稀疏矩阵的三元组顺序表存储表示及其转置算法
稀疏矩阵的三元组顺序表存储表示及其转置算法目录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的情况下,只有少数非零元素的情况。
稀疏矩阵——三元组顺序表
稀疏矩阵——三元组顺序表⽬录稀疏矩阵假设m*n的矩阵中,有t的⾮零元,令s=t/m * n,当,s<=0.05时,称此矩阵为稀疏矩阵,简单理解就是⾮零元特别少的矩阵//⼀般矩阵a1 2 3a= 4 5 67 8 9//稀疏矩阵s0 0 0 0 00 2 0 0 5s= 0 0 3 0 00 0 0 0 4矩阵的转置⼀个m * n的矩阵转置后变为 n * m的矩阵//3*2的矩阵-转置前1 24 57 8//转置后变为2*31 4 72 5 8转置后的矩阵每个元素的下表与原来的下表刚好相反,例如上⾯4转置前的下标为(2,1),转置后变为(1,2);矩阵压缩存储-三元组顺序表之所以引⼊三元组顺序表,是因为,对于稀疏矩阵⽽⾔,⽤传统的存储⽅法会造成存储空间的浪费0 12 9 0 0 0 00 0 0 0 0 0 0-3 0 0 0 0 14 0M= 0 0 24 0 0 0 00 18 0 0 0 0 015 0 0 -7 0 0 0//上⾯矩阵⽤三元组表⽰i j v1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7typedef struct{int i,j; //⾏坐标、列坐标ElemType e; //元素}Triple;typedef struct{Triple date[MAXSIZE+1]; //0不存储元素int mu,nu,tu; //⾏数、列数、⾮零元个数}TSMatrix;稀疏矩阵的转置传统⽅法的转置算法时遍历矩阵的每⼀项,交换其下标值即可for(col=1;col<=nu;col++){for(row=1;row<=mu;row++){T[col][row]=M[row][col]}}//时间复杂度 : O(nu*mu)利⽤三元组顺序表进⾏存储的稀疏矩阵要想实现转置显然不能⽤上⾯的算法,下⾯介绍两种⽅法:第⼀种:以列序为主序的转置//置换前存储位置i j v1 2 12 -> M.date[1]1 3 9 -> M.date[2]3 1 -3 -> M.date[3]3 6 14 -> M.date[4]4 3 24 -> M.date[5]5 2 18 -> M.date[6]6 1 15 -> M.date[7]6 4 -7 -> M.date[8]//置换后存储位置i j v1 3 -3 -> T.date[1]1 6 15 -> T.date[2]2 1 12 -> T.date[3]2 5 18 -> T.date[4]3 1 9 -> T.date[5]3 4 24 -> T.date[6]4 6 -7 -> T.date[7]6 3 14 -> T.date[8]void TransposeSMatrix(TSMatrix *T1,TSMatrix *T2){T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){int q=1,col,p;for(col=1;col<=T1->nu;col++) //矩阵列循环{for(p=1;p<=T1->tu;p++) //遍历所有元素{if(T1->date[p].j==col) //当元素在col列时{T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;q++;}}}}}//上述代码,当矩阵运算为满时,即tu=mu*nu,其时间复杂度为O(nu*nu*mu)//这种情况与经典算法相⽐,虽节省了存储空间,但是效率较低第⼆种:快速转置第⼀种算法是通过遍历所有元素的下标,从⽽确定其在转置后数组中的位置,快速转置的思想就是,预先确定每⼀列第⼀个⾮零元在对应转置后的数组date中的位置;因此需要两个辅助数组num[]:⽤来存放每⼀列的⾮零元个数cpot[]:存放第⼀个⾮零元在转置后数组date中的位置num[]数组的值很好求,只需要遍历⼀次所有元素即可for(t=1;t<=T1->tu;t++)++num[T1->date[t].j];对于cpot[],有⼀个规律col 1 2 3 4 5 6 7num[col] 2 2 2 1 0 1 0cpot[col] 1 3 5 7 8 8 9//规律copt[1]=1copt[col]=copt[col-1]+num[col-1]代码:void FastTransposeSMatrix(TSMatrix *T1,TSMatrix *T2){int num[T1->nu],cpot[T1->nu];int col,p,q,t;T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){//初始化每列⾮零元个数为0for(col=1;col<=T1->nu;col++){num[col]=0;}//求每列⾮零元个数for(t=1;t<=T1->tu;t++){++num[T1->date[t].j];}//求每列第⼀个⾮零元转置后的位置cpot[1]=1;for(col=2;col<=T1->nu;col++){cpot[col]=num[col-1]+cpot[col-1];}//遍历所有元素for(p=1;p<=T1->tu;p++){col=T1->date[p].j; //获取列坐标q=cpot[col]; //获取新位置T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;++cpot[col]; //之所以这个地⽅要++,因为每列⾮零元可能不⽌⼀个 }}}完整代码:#include <stdio.h>#include <stdlib.h>#define MAXSIZE 12500 //⾮零元个数的最⼤值typedef int ElemType;typedef struct{int i,j;ElemType e;}Triple;typedef struct{Triple date[MAXSIZE+1];int mu,nu,tu;}TSMatrix;//输⼊元素void Insert(TSMatrix *T){printf("请依次输⼊⾏数i、列数j、⾮零元个数sum:\n");int sum ;scanf("%d%d%d",&T->mu,&T->nu,&sum);T->tu=sum;int x,y,num;printf("请依次输⼊矩阵⾮零元的⾏坐标i、列坐标j、元素值x:\n");printf("i j v\n");for(int i=1 ;i<=sum;i++){scanf("%d%d%d",&x,&y,&num);T->date[i].i=x;T->date[i].j=y;T->date[i].e=num;}}//第⼀种转置⽅法void TransposeSMatrix(TSMatrix *T1,TSMatrix *T2)T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){int q=1,col,p;for(col=1;col<=T1->nu;col++){for(p=1;p<=T1->tu;p++){if(T1->date[p].j==col){T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;q++;}}}}}//输出矩阵⾮零元void Show(TSMatrix *T){printf("转置后的矩阵:\n");printf("i j v\n");for(int i=1;i<=T->tu;i++){printf("%d %d %d\n",T->date[i].i,T->date[i].j,T->date[i].e); }}//快速转置void FastTransposeSMatrix(TSMatrix *T1,TSMatrix *T2){int num[T1->nu],cpot[T1->nu];int col,p,q,t;T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){//初始化每列⾮零元个数为0for(col=1;col<=T1->nu;col++){num[col]=0;}//求每列⾮零元个数for(t=1;t<=T1->tu;t++){++num[T1->date[t].j];}cpot[1]=1;for(col=2;col<=T1->nu;col++){cpot[col]=num[col-1]+cpot[col-1];}for(p=1;p<=T1->tu;p++){col=T1->date[p].j;q=cpot[col];T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;++cpot[col];}}}int main(){TSMatrix T,T1,*q,*p;p=&T;q=&T1;Insert(p);//测试第⼀种转置⽅法TransposeSMatrix(p, q);Show(q);//测试快速转置FastTransposeSMatrix(p, q);Show(q);}/* 测试请依次输⼊⾏数i、列数j、⾮零元个数sum:6 7 8请依次输⼊矩阵⾮零元的⾏坐标i、列坐标j、元素值x:1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7转置后的矩阵:i j v1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14转置后的矩阵:i j v1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14Program ended with exit code: 0*/我不⽣产代码,我只是代码的搬运⼯。
【免费下载】用三元组表存储表示求稀疏矩阵M转置函数T
//输出稀疏矩阵 M void PrintSMatrix(TSMatrix M) {
int i; printf("**************************************\n"); for(i=1;i<=M.tu;i++)
对全部高中资料试卷电气设备,在安装过程中以及安装结束后进行高中资料试卷调整试验;通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关,系电,力根通保据过护生管高产线中工敷资艺设料高技试中术卷资,配料不置试仅技卷可术要以是求解指,决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资,配料而置试且时卷可,调保需控障要试各在验类最;管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下,安与要全过加,度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高;试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中,核资或对料者定试对值卷某,弯些审扁异核度常与固高校定中对盒资图位料纸置试,.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置,弯高尤曲中其半资要径料避标试免高卷错等调误,试高要方中求案资技,料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高,术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术,管以术来架及避等系免多统不项启必方动要式方高,案中为;资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资,管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装,工置合作调理并试利且技用进术管行,线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确:指灵在导活分。。线对对盒于于处调差,试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷,术调应问试采题技用,术金作是属为指隔调发板试电进人机行员一隔,变开需压处要器理在组;事在同前发一掌生线握内槽图部内 纸故,资障强料时电、,回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资,料料线试试缆卷卷敷试切设验除完报从毕告而,与采要相用进关高行技中检术资查资料和料试检,卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况,然后根据规范与规程规定,制定设备调试高中资料试卷方案。
数据结构课程设计稀疏矩阵
稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。
在程序设计中,考虑到方法的难易程度,采用了先用三元组实现稀疏矩阵的输入,输出,及其转置,相加,相乘操作的方法,再在十字链表下实现。
程序通过调试运行,结果与预期一样,初步实现了设计目标。
关键词程序设计;稀疏矩阵;三元组;十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。
稀疏矩阵采用三元组和十字链表表示,并在两种不同的存储结构下,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;求出A的转置矩阵D,输出D;求两个稀疏矩阵A和B的相乘矩阵E,并输出E。
1.2课程设计性质数据结构课程设计是重要地实践性教学环节。
在进行了程序设计语言课和《数据结构》课程教学的基础上,设计实现相关的数据结构经典问题,有助于加深对数据结构课程的认识。
本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现,包括在三元组和十字链表下存储稀疏矩阵,并对输入的稀疏矩阵进行转置,相加,相乘等操作,最后把运算结果输出。
此课程设计要求对数组存储结构和链表存储结构非常熟悉,并能熟练使用它们。
1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上,掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置,相加,相乘等基本操作,并用不同的方法输出结果,进一步掌握设计、实现较大系统的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。
2需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化,包括在三元组结构下和十字链表结构下。
首先要定义两种不同的结构体类型,在创建稀疏矩阵时,需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵,在输入出现错误时,能够对错误进行判别处理,初始化稀疏矩阵都为空值,特别注意在十字链表下,对变量进行动态的地址分配。
稀疏矩阵快速转置
题目:假设稀疏矩阵A采用三元组表表示,编写程序实现该矩阵的快速转置要求:输入一个稀疏矩阵A,由程序将其转换成三元组表存储;转置后的三元组表,由程序将其转换成矩阵形式后输出。
一、需求分析1.用户可以根据自己的需求输入任意一个稀疏矩阵,通过程序将其转换成三元组存储方式;2.并且能够完成矩阵的转置功能,要求需要使用的方法是快速转置的方法。
3.最后要够显示原矩阵和转置后的矩阵让用户能进行比较。
4.程序执行的命令包括:(1)构造稀疏矩阵M (2)求转转矩阵T (3)显示(打印)矩阵二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT SparseMatrix {数据对象:D={aij :|aij∈TermSet,i=1…m,m≥0,j=1…n,n≥0 m和n分别成为矩阵的行数和列数 }数据关系:R={Row,Col}Row ={<ai,j ,ai,j+1>|1≤i≤m,1≤j≤n-1 }Col ={<ai,j ,ai+1,j>|1≤i≤m-1,1≤j≤n }基本操作:CreateSMtrix(& M)操作结果:创建稀疏矩阵M。
DestroySMaix(&M)初始条件:稀疏矩阵M已存在。
操作结果:销毁稀疏矩阵M。
PrintSMatrix(L)初始条件:稀疏矩阵M已经存在。
操作结果:输出稀疏矩阵M。
CopySMatrix(M,&T)初始条件:稀疏矩阵M已经存在。
操作结果:由稀疏矩阵M复制得到T。
TransposeSMatrix(M,&T)初始条件:稀疏矩阵M已经存在。
操作结果:求稀疏矩阵M的转转矩阵T。
}ADT SparseMatrix2. 本程序有三个模块:⑴主程序模块main(){初始化;{接受命令;显示结果;}}⑵矩阵压缩存储单元模块:实现链表抽象数据类型操作,即函数的定义模块;三、详细设计⒈元素类型,结点类型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 函数调用关系四、调试分析⒈在定义变量的时候,我运用动了整型的全局变量a和b。
三元组表示稀疏矩阵的转置(一般算法和快速算法)
一、设计要求1.1 问题描述稀疏矩阵是指那些多数元素为零的矩阵。
利用稀疏特点进行存储和计算可以大大节省存储空间,提高计算效率。
求一个稀疏矩阵A的转置矩阵B。
1.2需求分析(1)以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现稀疏矩阵的转置运算。
(2)稀疏矩阵的输入形式采用三元组表示,运算结果则以通常的阵列形式列出。
(3)首先提示用户输入矩阵的行数、列数、非零元个数,再采用三元组表示方法输入矩阵,然后进行转置运算,该系统可以采用两种方法,一种为一般算法,另一种为快速转置算法。
(4)程序需要给出菜单项,用户按照菜单提示进行相应的操作。
二、概要设计2.1存储结构设计采用“带行逻辑链接信息”的三元组顺序表表示矩阵的存储结构。
三元组定义为:typedef struct{int i;//非零元的行下标int j;//非零元的列下标ElemType e; //非零元素值}Triple;矩阵定义为:Typedef struct{Triple data[MAXSIZE+1]; //非零元三元组表int rpos[MAXRC+1]; //各行第一个非零元的位置表int mu,nu,tu; //矩阵的行数、列数和非零元个数}RLSMatrix;例如有矩阵A,它与其三元组表的对应关系如图2.2 系统功能设计本系统通过菜单提示用户首先选择稀疏矩阵转置方法,然后提示用户采用三元组表示法输入数据创建一个稀疏矩阵,再进行矩阵的转置操作,并以通常的阵列形式输出结果。
主要实现以下功能。
(1)创建稀疏矩阵。
采用带行逻辑连接信息的三元组表表示法,提示用户输入矩阵的行数、列数、非零元个数以及各非零元所在的行、列、值。
(2)矩阵转置。
<1>采用一般算法进行矩阵的转置操作,再以阵列形式输出转置矩阵B。
<2>采用快速转置的方法完成此操作,并以阵列形式输出转置矩阵B。
三、模块设计3.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.稀疏矩阵的快速转置稀疏矩阵的转置是将矩阵的行和列交换,同时保持非零元素的位置和数值不变。
在传统的存储方式下,稀疏矩阵的转置操作相对复杂且耗时。
然而,采用三元组压缩存储结构后,稀疏矩阵的快速转置变得十分简便。
通过交换三元组中的行坐标和列坐标,即可完成稀疏矩阵的快速转置操作。
5.个人观点和理解我认为三元组压缩存储结构的出现,极大地解决了稀疏矩阵在存储和运算中的效率问题。
通过将矩阵的非零元素信息进行压缩存储,不仅节省了存储空间,同时也提高了计算效率。
在实际应用中,三元组压缩存储结构能够更好地满足对存储空间和计算效率有较高要求的场景,为稀疏矩阵的处理提供了更为便利和高效的途径。
数据结构-稀疏矩阵的三元组表存储方法
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求得 b .data 4 2 5 18
a .data 5 a .data 6 a .data 7
4 3 24
5 2 18 无!
6 1 15
b .data 5 b .data 6 b .data 7
31 9 3 4 24 4 6 -7
b .data 2 1 6 15
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求解 b .data 4 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
b .data 6 3 4 24
a .data 7 6 1 15
a .data 5 4 3 24
b .data 5
a .data 6 5 2 18
b .data 6
a .data 7 6 1 15
b .data 7
a .data 8 6 4 -7
b .data 8
a. mu=6 a. nu=7 a. tu=8 注:p=1:8,寻找 j=col 的a.data[ p]
a .data 2 1 3 9 Col=6 b .data 2 1 6 15
a .data 3 a .data 4
3 1 -3
b .data 3
3 6 14 求得 b .data 4
2 1 12 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
2.求解步骤分析:p=1:8, q的值=7
实现稀疏矩阵采用三元组表示的基本运算实验报告
实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵(采用三元组表示)的基本运算实验报告一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:(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元素行列变换一下赋值到新的矩阵中即可。
数据结构-稀疏矩阵的三元组表存储方法
M=
注意:用变量 和 分别存放矩阵 注意 用变量a和 b分别存放矩阵 用变量 M和N (TSMatrix a, TSMatrix b), 和 即要从已知变量a来求得变量 来求得变量b的 即要从已知变量 来求得变量 的 值。
也既要完成如下求解工作: 也既要完成如下求解工作:
a . data p a .data 1 a .data 2 a .data 3 a .data 4 a .data 5 a .data 6 a .data 7 a .data 8 i 1 1 3 3 4 5 6 6 j 2 3 1 6 3 2 1 4 e 12 9 -3 14 24 18 15 -7 b . data q b .data 1 b .data 2 b .data 3 i 1 1 2 2 3 3 4 6 j 3 6 1 5 1 4 6 3 e -3 15 12 18 9 24 -7 14
求得
b .data 4 b .data 5
无!
b .data 6 b .data 7 b .data 8
a. mu=6 a. nu=7 a. tu=8
注:p=1:8,寻找 j=col 的a.data[ p] 寻找
2.求解步骤分析:p=1:8, q的值 求解步骤分析: 的值=8 求解步骤分析 的值
a . data p a .data 1 a .data 2 a .data 3 a .data 4 a .data 5 a .data 6 a .data 7 a .data 8 i 1 1 3 3 4 5 6 6 j 2 3 1 6 3 2 1 4 e 12 9 Col=6 -3 14 求得 24 18 15 -7 b . data q b .data 1 b .data 2 b .data 3 b .data 4 b .data 5 b .data 6 b .data 7 b .data 8 i 1 1 2 2 3 3 4 6 j 3 6 1 5 1 4 6 e -3 15 12 18 9 24 -7
三元组表示稀疏矩阵转置
三元组表示稀疏矩阵转置
随着时代的进步,互联网已经深入到了我们的各个层面,其成功的关键之一就
在于数据处理技术。
稀疏矩阵转置是构成这一技术的基础之一,主要目的是改变二维矩阵的行和列。
这里要介绍的是一种特殊的“三元组表示稀疏矩阵转置”技术,它可以更加高效地将变换后的矩阵存储在硬盘上以便以后可以重用。
三元组表示稀疏矩阵转置处理的思路是,首先,将需要转置的稀疏矩阵以一个“非零元素”列表的形式读入,记为(row,col,data),其中row表示该非零元素所
处的行数,col表示列数,data表示该非零元素的值;然后,根据row和col的值,计算变换后的稀疏矩阵的最终坐标依次给出(col,row);最后,将所有非零元素的
坐标以及对应的值,按照升序排序,用“三元组表示形式”写入硬盘中以作备份。
三元组表示稀疏矩阵转置也是一种特殊的“非零元素”列表构建技术。
它把矩
阵转换成一系列索引型(index type)的非零元素数据,这既可以更加有效地把变换后的矩阵存储起来,也可以有效地提高运算效率,避免无谓的存储和消耗。
从长远来看,三元组表示稀疏矩阵转置无疑是一种重要的数据技术,它的成功
不仅取决于它的有效简便度,而且取决于它有助于改善计算处理效率,提高输出效果,从而使数据技术更为可靠,有助于推动信息革命更大范围的发展。
三元组结构实现稀疏矩阵转置算法的分析
三元组结构实现稀疏矩阵转置算法的分析文章简要叙述了稀疏矩阵压缩存储的三元组表示法及其基于此种结构的矩阵的转置运算。
探讨了基于三元组结构的矩阵转置算法的具体实现方法及其时空复杂度的问题。
【关键词】稀疏矩阵压缩存储三元组转置算法在一些特殊矩阵中,如对称矩阵和上下三角矩阵,非零元素一般都有明显的规律,从而都可以压缩到一维数组里面,然而,实际应用中经常会遇到这样一些矩阵,它们非零元素少,且分布不均匀,且没有明显的规律,称之为稀疏矩阵。
按照压缩存储的思想,只需存储矩阵中的非零元素。
为了便于存取和检索,一般在存储的时候必须带有合适的辅助信息,即同时记录下它所在的行列的位置等等。
在实际应用中,一般我们采取的是用三元组和十字链表两种表示方法来实现稀疏矩阵的存储及其运算。
稀疏矩阵在数值计算、电力系统的潮流计算、天气预报、工程分析计算等方面都有着大量的应用,不少实际问题都可以转化为对稀疏矩阵的计算问题。
了解稀疏矩阵的各种操作变得尤为重要。
1 基本概念设矩阵中有t个非零元素,若t远远小于矩阵元素的总数,则称该矩阵为稀疏矩阵。
通常,在m×n 的矩阵中,存在t个非零元素。
设δ= t/(m*n),则称δ为矩阵的稀疏因子,一般认为当δ≤0.05时为稀疏矩阵。
在存储稀疏矩阵时,为了节约存储单元,很自然的压缩方法就是只存储非零元素,但由于非零元素的分布一般是没有规律的,因此在存储非零元素的同时,还必须存储相应的辅助信息,才能准确迅速确定一个非零元素是矩阵中的哪一个元素。
最简单的办法就是将非零元素的值和它所在的行列号作为一个结点存放到一起,于是矩阵中的每一个非零元素就由一个三元组(i,j,aij)唯一确定。
显然,稀疏矩阵的压缩存储方法会让其失去随机存取功能。
2 三元组表示稀疏矩阵转置算法的实现用三元组来表示非零元素时稀疏矩阵的压缩存储方法的具体数据类型说明如下:三元组表示的稀疏矩阵,如何实现转置算法呢?矩阵的转置是基本的矩阵运算,对于一个m×n 的矩阵M,它的转置N是一个n×m 的矩阵,且有N(i,j)=M(j,i)。
用三元组表存储表示,求稀疏矩阵M转置函数T
用三元组表存储表示,求稀疏矩阵M转置函数T 实验目的利用三重表存储表示,得到稀疏矩阵M的转置函数T实验内容在计算机上编程和调试。
采用三元组表存储表示,求稀疏矩阵m转置函数t编程//采用三元组表存储表示,求稀疏矩阵m转置函数t#包括#definemaxsize100typedefstruct{inti,j;inte;}三部分的typedefstruct{tripledata[maxsize+1];intmu,nu,tu;}tsmatrix;//创建稀疏矩阵Mcreatesmatrix(tsmatrix*m){inti,m,n,e,k;printf(\输入矩阵m的行数、列数、非零元的个数(中间用逗号隔开):\scanf(\(*m).data[0].i=0;printf(\for(i=1;i<=(*m).tu;i++){Do{printf(\输入%d个非零元素的行(1~%d)列(1~%d)值和值:\scanf(\k=0;if(m<1||m>(*m).mu||n<1||n>(*m).nu)k=1;if(m//输出稀疏矩阵Mvoidprintsmatrix(tsmatrixm){inti;printf(\for(i=1;i<=m.tu;i++)printf(\printf(\p rintf(\}//求稀疏矩阵M的转置矩阵tvoidtransposesmatrix(tsmatrixm,tsmatrix*t){intp,q,col;(*t).mu=m.nu;(*t).nu=m.m u;(*t).tu=m.tu;if((*t).tu){q=1;for(col=1;col<=m.nu;++col)对于(p=1;p<=m.tu;++p)如果(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;}返回1;}//打印矩阵函数,以通常形式输出矩阵voidprint(tsmatrixa){intk=1,a,b;intm[maxsize][maxsize];printf(\非零元素所对应的位置:\\n\printf(\for(a=0;a)printf(\printf(\}//Main函数intmain(){tsmatrixm,t;printf(\创建矩阵m:\createsmatrix(&m);printf(\矩阵m的三元组表为:\\n\printsmatrix(m);print(m);transposesmatrix(m,&t);printf(\稀疏矩阵m的转换矩阵t的三元组表为:\\n\printsmatrix(t);print(t);printf(\getchar();return0;}运行程序:程序解决方案:1.首先是将程序的开头写好,定义非零元个数最多为100.将非零元素的行下标、列下标和非零元素定义为int类型。
稀疏矩阵基本操作 实验报告
稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵的压缩储存结构,以及稀疏矩阵的三元组表表示方法下的转置、相加、相乘等算法二、实验目的1.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义,掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素(三元组分别储存非零元素的行下标,列下标和元素值)。
除了三元组表本身,储存一个稀疏矩阵还需要额外的三个变量,分别储存矩阵的非零元个数,矩阵的行数和矩阵的列数。
2.稀疏矩阵的创建算法:第一步:根据矩阵创建一个二维数组,表示原始矩阵第二步:取出二维数组中的元素(从第一个元素开始取),判断取出元素是否为非零元素,如果为非零元素,把该非零元素的数值以及行下标和列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。
第三步:重复第二步,知道二维数组中所有的元素已经取出。
3.稀疏矩阵倒置算法:第一步:判断进行倒置的矩阵是否为空矩阵,如果是,则直接返回错误信息。
第二步:计算要倒置的矩阵每列非零元素的数量,存入到num数组(其中num[i] 代表矩阵中第i列非零元素的个数)。
以及倒置后矩阵每行首非零元的位置,存入cpot 数组中(其中cpot表示倒置后矩阵每行非零元的位置,对应表示原矩阵每列中第一个非零元的位置)。
第三步:确定倒置后矩阵的行数和列数。
第四步:取出表示要导致矩阵中三元组表元素{e, I, j}(第一次取出第一个,依次取出下一个元素),从第二步cpot数组中确定该元素倒置后存放的位置(cpot[j]),把该元素的行下标和列下标倒置以后放入新表的指定位置中。
cpot[j] 变量加一。
第五步:重复第四步,直到三元组表中所有的元素都完成倒置。
第六步:把完成倒置运算的三元组表输出。
4.稀疏矩阵加法算法:第一步:检查相加两个矩阵的行数和列数是否相同,如果相同,则进入第二步,否则输出错误信息。
第二步:定义变量i和j,用于控制三元组表的遍历。
实验四稀疏矩阵三元组下转置
实验四、稀疏矩阵三元组下转置一、实验内容将稀疏矩阵中的每个非零元素aij表示为(i, j, v),即(行号,列号,非零元素值).称为三元组表示法。
用结构类型来描述三元组。
将稀疏矩阵的非零元素对应的三元组所构成的集合,按行优先的顺序排列成一个线性表。
在稀疏矩阵用三元组顺序表存储结构下,实现稀疏矩阵转置,得到其转置矩阵的三元组顺序表存储表示。
要求:1)采用转置算法Ⅰ:直接取,顺序存2)采用转置算法Ⅱ:顺序取,直接存。
要使用两个辅助一维数组,分别先计算出原矩阵每一列的非零元个数以及每一列的第一个非零元在转置矩阵的三元组顺序表中的存储位置。
二、实验目的1. 掌握稀疏矩阵的三元组顺序表存储结构;2. 掌握稀疏矩阵转置算法Ⅰ;3. 掌握稀疏矩阵转置算法Ⅱ三、实验代码//文件:SparseMatrix.htemplate <class T>struct element{int row, col; //行数、列数T item; //元素值};const int MaxTerm=100;template <class T>class SparseMatrix{ public:SparseMatrix(){};SparseMatrix(int intmu,int intnu,int inttu,element<T> datatemp[]);//有参构造函数,初始化稀疏矩阵~SparseMatrix(){}; //析构函数,释放存储空间element<T> GetMatrix(int intnumber);//输出下标对应的数组元素void Prt();//显示三元组顺序表void Trans1(SparseMatrix<T> &B);//直接取、顺序存的矩阵转置算法void Trans2(SparseMatrix<T> A, SparseMatrix<T> &B);//顺序取、直接存的矩阵转置算法private:element<T> data[MaxTerm]; //矩阵非零元素int mu, nu, tu; //行数、列数、非零元个数};// 文件:SparseMatrix.cpp#include "SparseMatrix.h" //引用三元组顺序表的头文件#include <string> //引用string库函数的头文件using namespace std;//指出后续的所有的程序语句都在名字空间std内/*前置条件:三元组顺序表不存在输入:三元组顺序表的行数(intmu)、列数(intnu)、非零元个数(inttu)、初始三元组(datatemp[])功能:三元组顺序表的初始化输出:无后置条件:建立一个三元组顺序表*/template <class T>SparseMatrix<T>::SparseMatrix(int intmu,int intnu,int inttu,element<T> datatemp[]){if (inttu >MaxTerm ) throw "构造函数的初始化参数不正确";mu = intmu;nu = intnu;tu = inttu;for(int i=0;i<inttu;i++){data[i] = datatemp[i];}}/*前置条件:三元组顺序表已存在输入:下标(intnumber)功能:读取这组下标对应的数组元素输出:对应元素后置条件:三元组顺序表不变*/template <class T>element<T> SparseMatrix<T>::GetMatrix(int intnumber){if(intnumber>=tu || intnumber < 0) throw "输入位置不正确";return data[i];}/*前置条件:无输入:无功能:显示三元组顺序表输出:无后置条件:建立一个三元组顺序表*/template <class T>void SparseMatrix<T>::Prt(){for(int i=0;i<tu;i++){cout<<data[i].row<<" "<<data[i].col<<" "<<data[i].item<<"\n";}}/*前置条件:无输入:待转置的源三元组顺序表(A)和目标三元组顺序表(B)的引用功能:对三元组顺序表进行转置输出:无后置条件:三元组顺序表A的转置结果放在了B中*/template <class T>void SparseMatrix<T>::Trans1(SparseMatrix<T> &B){int pb,pa;B.mu=this->nu; B.nu=this->mu; B.tu=this->tu;//设置行数、列数、非零元素个数 if (B.tu>0) //有非零元素则转换{pb = 0;for (int col=0; col<this->nu; col++) //依次考察每一列 for (pa=0; pa<this->tu; pa++) //在A中扫描整个三元组表if (this->data[pa].col==col ) //处理col列元素{B.data[pb].row= this->data[pa].col ;B.data[pb].col= this->data[pa].row ;B.data[pb].item= this->data[pa].item;pb++;}}}/*前置条件:无输入:待转置的源三元组顺序表(A)和目标三元组顺序表(B)的引用功能:对三元组顺序表进行转置输出:无后置条件:三元组顺序表A的转置结果放在了B中*/template <class T>void SparseMatrix<T>::Trans2(SparseMatrix<T> A, SparseMatrix<T> &B){int i,j,k,num[MaxTerm],cpot[MaxTerm];B.mu=A.nu; B.nu=A.mu; B.tu=A.tu;//设置行数、列数、元素个数if (B.tu>0) //有非零元素则转换{for (i=0; i<A.nu; i++) num[i]=0; //A中每一列非零元素的个数初始化为0 for (i=0; i<A.tu; i++)//求矩阵A中每一列非零元素的个数{ j= A.data[i].col; //取三元组的列号num[j]++;}cpot[0]=0; //A中第0列第一个非零元素在B中的位置为0for (i=1; i<A.nu; i++) //求A中每一列第一个非零元素在B中的下标cpot[i]= cpot[i-1]+num[i-1];for (i=0; i<A.tu; i++)//扫描三元组表A{j=A.data[i].col; //当前三元组的列号k=cpot[j]; //当前三元组在B中的下标B.data[k].row= A.data[i].col ;B.data[k].col= A.data[i].row ;B.data[k].item= A.data[i].item;cpot[j]++; //预置同一列的下一个三元组的下标}}}//文件:SparseMatrixMain.cpp#include <iostream> //引用输入输出流库函数的头文件#include "SparseMatrix.cpp" ////引用广义表的成员函数文件#include <string> //引用string库函数的头文件using namespace std; //指出后续的所有的程序语句都在名字空间std内int main(){try{//建立一个element<int>类型的数组(A)element<int> A[7]={{0,0,15},{0,3,22},{0,5,-15},{1,1,11},{1,2,3},{2,3,6},{4,0,91}};SparseMatrix<int> sparsematrixB;//构造三元组顺序表来存储转置后的三元组顺序表 SparseMatrix<int> sparsematrixA(5,6,7,A);//构造三元组顺序表cout<<"原三元组顺序表如下:"<<"\n";sparsematrixA.Prt();//显示三元组顺序表sparsematrixA.Trans1(sparsematrixB);cout<<"使用直接取、顺序存转置算法转置后的三元组顺序表如下:"<<"\n";sparsematrixB.Prt();//显示三元组顺序表sparsematrixA.Trans2(sparsematrixA,sparsematrixB);cout<<"使用顺序取、直接存转置算法转置后的三元组顺序表如下:"<<"\n";sparsematrixB.Prt();//显示三元组顺序表}catch(char* e){ cout<<e; }return 0;}四、调试和运行结果在完成算法的程序实现后,用任意的一组数据来加以测试运行,对运行结果加以分析,检查运行结果是否正确。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}TSMatrix;
void creatTSMatrix(TSMatrix *A)
{
int temp,row,col,k;
printf("row,column:");
scanf("%d%d",&A->m,&A->n);
printf("input data must be followed by above row and column :\n");
printf("\n");
}
void FastTransposeTSMatrix(TSMatrix A,TSMatrix *B)
{
int col,t,p,q;
int num[MAXSIZE],position[MAXSIZE];
B->len=A.len;
B->n=A.m;
B->m=A.n;
if(B->len)
#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 1000
typedef int ElementType;
typedef struct
{
int row,col;
ElementType e;
}Triple;
typedef struct
{
Triple data[MAXSIZE+1];
}
}
}
void visit(TSMatrix *B)
{
int row,col,p=1;
int d;
printf("the transposed Triple translate into Matrix is:\n");
for(row=1;row<=B->m;row++)
{ printf("\n");
printf("the Matrix A translate into Triple is:\n\n");
for(row=1;row<=A->len;row++)
printf("%3d%3d%3d\t",A->data[row].row,A->data[row].col,A->data[row].e);
for(col=1;col<=B->n;col++)
{ if(B->data[p].row==row&& B->data[p].col==col)
{ d=B->data[p].e;
p++;
}
else d=0;
printf("%6d",d);
}
}ቤተ መጻሕፍቲ ባይዱ
}
main()
{
TSMatrix A;
TSMatrix B;
clrscr();
creatTSMatrix(&A);
FastTransposeTSMatrix(A,&B);
visit(&B);
getch();
}
for(p=1;p<=A.len;p++)
{
col=A.data[p].col;
q=position[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;
position[col]++;
{
for(col=1;col<=A.n;col++){num[col]=0;}
for(t=1;t<=A.len;t++)
{num[A.data[t].col]++;}
position[1]=1;
for(col=2;col<=A.n;col++)
position[col]=position[col-1]+num[col-1];
k=1;
for(row=1;row<=A->m;row++)
for(col=1;col<=A->n;col++)
{
scanf("%d",&temp);
if(temp)
{
A->data[k].row=row;
A->data[k].col=col;
A->data[k].e=temp;
k++;
}
}
A->len=k-1;