数据结构---三元组顺序表------稀疏矩阵的转置和快速转置

合集下载

稀疏矩阵三元组快速转置(转poklau123写的很清楚)

稀疏矩阵三元组快速转置(转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位了。

这样,读取每⼀项,都能在三元表中找到相应的位置,这就是稀疏矩阵快速转置的原理。

当然,上⾯只是快速转置的原理,要实现它,就要设计算法来实现了。

数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现

数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现

typedef int ElemType;// 稀疏矩阵的三元组顺序表存储表示#define MAXSIZE 100 // 非零元个数的最大值typedef struct{int i,j; // 行下标,列下标ElemType e; // 非零元素值}Triple;typedef struct{Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数}TSMatrix;// 创建稀疏矩阵Mint CreateSMatrix(TSMatrix *M){int i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素个数:(逗号)\n");scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);(*M).data[0].i=0; // 为以下比较顺序做准备for(i = 1; i <= (*M).tu; i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),""列(1~%d),元素值:(逗号)\n", 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; //该下标所对应的值}return 1;}// 销毁稀疏矩阵M,所有元素置空void DestroySMatrix(TSMatrix *M){(*M).mu=0;(*M).nu=0;(*M).tu=0;}// 输出稀疏矩阵Mvoid PrintSMatrix(TSMatrix M){int i;printf("\n%d行%d列%d个非零元素。

稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法目录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的情况下,只有少数非零元素的情况。

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析

数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析稀疏矩阵是指矩阵中大部分元素为零的特殊矩阵。

在实际应用中,稀疏矩阵经常出现,如图像处理、网络分析和科学计算等领域。

对于稀疏矩阵的存储和操作是数据结构中的重要内容。

本文将介绍稀疏矩阵的存储方式和相关操作的分析。

一、稀疏矩阵存储方式稀疏矩阵的存储方式有多种,其中三元组顺序表和二维数组是比较常用的方法。

1. 三元组顺序表三元组顺序表是一种基于行优先存储的方式,可以将稀疏矩阵以非零元素的形式存储起来。

主要包括行号、列号和元素值三个信息。

以一个4x5的稀疏矩阵为例,其中有三个非零元素分别为A[1][2]=3, A[2][3]=4, A[3][4]=5。

可以使用三元组顺序表来存储:```行号列号元素值1 2 32 3 43 4 5```三元组顺序表的优点是可以节省存储空间,同时也方便进行矩阵的操作。

但是在进行元素的查找和修改时,效率较低。

2. 二维数组二维数组是一种常见的矩阵表示方法,可以直接使用二维数组来表示稀疏矩阵。

其中非零元素的位置用实际的值表示,其余位置用零值表示。

以同样的4x5的稀疏矩阵为例,使用二维数组存储如下:```0 0 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5```二维数组的优点是简单直观,并且可以快速进行元素的查找和修改。

但当稀疏矩阵的规模较大时,会造成较高的存储资源浪费。

二、稀疏矩阵的操作分析对于稀疏矩阵的操作,主要包括矩阵的转置、相加、相乘等。

1. 转置操作稀疏矩阵的转置是指将原始矩阵的行与列对调。

对于三元组顺序表来说,转置操作主要涉及到行号和列号的交换。

而对于二维数组来说,可以直接在取值的时候将行号和列号对调即可。

2. 相加操作稀疏矩阵的相加操作是指将两个矩阵对应位置的元素相加。

对于三元组顺序表来说,可以通过遍历两个矩阵的非零元素,并将其对应位置的元素相加。

而对于二维数组来说,可以直接将对应位置的元素相加即可。

3. 相乘操作稀疏矩阵的相乘操作是指将两个矩阵相乘得到一个新的矩阵。

Chapter52稀疏矩阵转置

Chapter52稀疏矩阵转置
cpot[col] = cpot[col-1] + num[col-1]; for (p=1; p<=M.tu; ++p) { 转置矩阵元素 } } // if return OK; } // FastTransposeSMatrix
二、行逻辑联接的顺序表
三元组顺序表又称有序的双下标 法,它的特点是,非零元在表中按行 序有序存储,因此便于进行依行顺序 处理的矩阵运算。然而,若需随机存 取某一行中的非零元,则需从头开始 进行查找。
}// TransposeSMatrix
首先应该确定转置矩阵中 每一行的第一个非零元在三元组中的位置。
1 2 15 1 5 -5 2 2 -7 3 1 36 3 4 28
col 1 2 3 4 5 Num[pos] 1 2 0 1 1 Cpot[col] 1 2 4 4 5
cpot[1] = 1; for (col=2; col<=M.nu; ++col)
其时间复杂度为: O(mu×nu)
实现三元组表存储的稀疏矩阵的转置运算
mu nu tu 678 ijv 1 2 12 139 3 1 -3 3 6 14 4 3 24 5 2 18 6 1 15 6 4 -7
mu nu tu 76 8 ij v 2 1 12 31 9 1 3 -3 6 3 14 3 4 24 2 5 18 1 6 15 4 6 -7
其时间复杂度为: O(m1×n2×n1)
• for (i=1; i<=m1; ++i) • for (j=1; j<=n2; ++j) { • Q[i][j]=0; • for(k(0---n1-1) • Q[i][j]+=M[i][k]*N[k][j]

数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法《数据结构》实验报告◎实验题⽬:稀疏矩阵的转置、加法(⾏逻辑链接表)◎实验⽬的:学习使⽤三元组顺序表表⽰稀疏矩阵,并进⾏简单的运算◎实验内容:以三元组表表⽰稀疏矩阵,并进⾏稀疏矩阵的转置和加法运算。

⼀、需求分析该程序⽬的是为了⽤三元组表实现稀疏矩阵的转置和加法运算。

1、输⼊时都是以三元组表的形式输⼊;2、输出时包含两种输出形式:运算后得到的三元组表和运算后得到的矩阵;3、测试数据:(1)转置运算时输⼊三元组表:1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7得到转置后的三元组表:1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14(2)进⾏加法运算时先输⼊矩阵A(以三元组表形式):1 1 12 2 22 3 43 1 -4输⼊矩阵B(以三元组表形式):1 3 -22 3 -53 1 83 2 -6A与B的和矩阵以矩阵形式输出为:1 0 -20 2 -14 -6 0(⼆) 概要设计为了实现上述操作⾸先要定义三元组表,稀疏矩阵:typedef struct{int i,j;int e;}Triple;//三元组typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}Matrix;//稀疏矩阵1.基本操作void CreatMatrix(Matrix *m)操作结果:创建⼀个稀疏矩阵。

void PrintMatrix(Matrix m)初始条件:矩阵m已存在。

操作结果:将矩阵m以矩阵的形式输出。

void FastTransposeMatrix(Matrix a,Matrix *b)初始条件:稀疏矩阵a已存在;操作结果:将矩阵a进⾏快速转置后存⼊b中。

void AddMatrix(Matrix a,Matrix b,Matrix *c)初始条件:稀疏矩阵a和b都已存在;操作结果:将矩阵a和b的和矩阵存⼊c中。

稀疏矩阵——三元组顺序表

稀疏矩阵——三元组顺序表

稀疏矩阵——三元组顺序表⽬录稀疏矩阵假设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*/我不⽣产代码,我只是代码的搬运⼯。

数据结构稀疏矩阵的表示和转置

数据结构稀疏矩阵的表示和转置

数据结构实验报告实验四稀疏矩阵的表示和转置一、实验目的1. 掌握稀疏矩阵的三元组顺序表存储结构2. 掌握稀疏矩阵的转置算法。

二、实验内容采用三元组表存储表示,求稀疏矩阵M的转置矩阵T。

(算法5.1)三、实验步骤:1. 构建稀疏矩阵M。

2. 求稀疏矩阵M的转置矩阵T。

3. 输出稀疏矩阵M和稀疏矩阵T。

四、算法说明首先要创建稀疏矩阵的三元组顺序表存储表示,定义mu,nu,tu分别表示矩阵的行数、列数和非零元个数。

在进行稀疏矩阵的转置时要做到(1):将矩阵的行列值相互交换;(2):将每个三元组的i,j相互调换;(3):重排三元组之间的次序便可实现矩阵的转置。

五、测试结果六、分析与探讨在此次程序中转置的方法称为快速转置,在转置前,应先求得M的每一列中非零元的个数,进而求得每一列的第一个非零元的位置。

七、附录:源代码数据结构实验报告源代码列在附录中,要求程序风格清晰易理解,有充分的注释。

有意义的注释行不少于30%。

#include <stdio.h>#define MAXSIZE 5#define MAXMN 200typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE];int rpos[MAXMN];int mu,nu,tu;//矩阵的行数、列数和非零元个数}TSMatrix; //行逻辑连接的顺序表int main(){printf("矩阵M\n");TSMatrix M,T;printf("i j v\n");int i;for(i=0;i<MAXSIZE;i++)scanf("%d %d %d",&M.data[i].i, &M.data[i].j, &M.data[i].e); printf("请输入矩阵M的行数mu,列数nu,及非零元的个数tu\n"); scanf("%d %d %d",&M.mu, &M.nu, &M.tu);//求稀疏矩阵M的转置矩阵TT.mu=M.nu; T.nu=M.mu; T.tu=M.tu;if(T.tu){int t, column, num[MAXMN]={0}; //用来统计M中每列非零元的个数for(t=0;t<M.tu;t++)++num[M.data[t].j];T.rpos[0]=0; for(column=1;column<T.mu;column++)T.rpos[column]=T.rpos[column-1]+num[column-1]; int p, q;for(p=0;p<M.tu;p++){column=M.data[p].j;q=T.rpos[column];T.data[q].i=M.data[p].j;T.data[q].j=M.data[p].i;数据结构实验报告T.data[q].e=M.data[p].e;T.rpos[column]++; //转置矩阵T中同一行的非零元的起始位置自增1 } }//输出矩阵M及转置矩阵Tprintf("\n矩阵T:\n");printf("i j v\n");for(i=0;i<T.tu;i++)printf("%d %d %d\n",T.data[i].i, T.data[i].j, T.data[i].e); printf("\n");return 0;}欢迎您的下载,资料仅供参考!致力为企业和个人提供合同协议,策划案计划书,学习课件等等打造全网一站式需求。

三元组稀疏矩阵快速转置C语言算法

三元组稀疏矩阵快速转置C语言算法
为了节省空间,可以 进行压缩存储,只需存储稀疏矩阵的非零元素。但是,为了实 现矩阵的各种运算,除了存储非零元素的值外,还必须同时记 下它所在的行和列。可以用一个三元组(i, j, aij)唯一地确 定矩阵中的一个非零元素,其中 i, j 分别表示非零元素的行 号和列号,aij 表示非零元素的值。
下面就是(算式 1)式中矩阵 M 的(5 行 6 列共有)8 个非零元 素的三元组表示:
四、快速转置算法
这两种算法的函数中,a 是已知的三元组表,为了使函数 得到转置后新的三元组表b, 这里使用的是传址调用的形参*b。
按照 a.data 中三元组的次序进行转置。转置后的元素 不连续存放,直接放到 b->data 中应有的位置上,这样既可 以避免元素移动,又只需对 a.data 扫描一次。为了确定矩阵 M 中的每一列(即 N 中每一行)的第一个非零元素在 b->data 中 应有的位置,需要先求得矩阵 M 中的每一列中非零元素的个 数。为此,需设置两个数组 num[1..n]和 pot[1..n],分别存 放在矩阵 M 中每一列的非零元素个数和每一列第 1 个非零元素 在 b->data 中的位置,即
二数组的三元组表示与稀疏矩阵在实际应用中往往会遇到一种大多数元素的值为零的矩阵只有少部分为非零元素这些非零元素在矩阵中的分布又没有一定的规?我们把它记作零元素个数非零元素个数即零元素个数远远大于非零元素个数
专业视窗
决策管理
Policy & Management
三元组稀疏矩阵快速转置 C 语言算法
徐光联
num[a.data[k].j]); }
pot[1]=0; for (col=2; col<=a.n; col++) { pot[col]=pot[col-1]+num[col-1]; printf("pot[%d]=%d\n",col,pot[col]); } for (p=0;p<a.t;p++) { col=a.data[p].j; q=pot[col]; b->data[q].i=a.data[p].j; b->data[q].j=a.data[p].i; fastran ( b->data[q].v=a.data[p].v; pot[col]++;

定义稀疏矩阵的三元组顺序存储结构

定义稀疏矩阵的三元组顺序存储结构

定义稀疏矩阵的三元组顺序存储结构下载提示:该文档是本店铺精心编制而成的,希望大家下载后,能够帮助大家解决实际问题。

文档下载后可定制修改,请根据实际需要进行调整和使用,谢谢!本店铺为大家提供各种类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,想了解不同资料格式和写法,敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!定义稀疏矩阵的三元组顺序存储结构稀疏矩阵是指大部分元素为零的矩阵。

数据结构25:矩阵转置算法(三元组顺序表)

数据结构25:矩阵转置算法(三元组顺序表)

数据结构25:矩阵转置算法(三元组顺序表)矩阵的转置实际上就是将数据元素的⾏标和列标互换,即 T(i,j) = M(j,i) 。

例如:图1 矩阵的转置相应地,三元组表转变为:图2 三元组表矩阵的转置,经历了三个步骤:矩阵的⾏数 n 和列数 m 的值交换;将三元组中的i和j调换;转换之后的表同样按照⾏序(置换前的列序)为主序,进⾏排序;实现三元组的转换,重点在第三步,实现算法有两种。

普通算法普通算法的实现过程为:1. 将矩阵的⾏数和列数进⾏调换;2. 遍历表 a 的 j 列(查找 j 的值,从 1 ⼀直到未转置之前的矩阵的列数 m ),遍历的过程,就可以⾃动存储为表 b 的形式。

因为在表 a 中 i 列的数值是从⼩到⼤的,在根据 j 列由上到下的遍历时, i 列同样也是有序的。

实现代码:TSMatrix transposeMatrix(TSMatrix M, TSMatrix T){ //⾏和列置换 T.m = M.n; T.n = M.m; T.num = M.num; if (T.num) { int q = 0; //依次遍历M矩阵的列(从1开始),的遍历的过程中将⾏标和列标置换,得到置换后的三元表T for (int col=1; col<=M.m; col++) { for (int p=0; p<M.num; 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].data = M.data[p].data; q++; } } } } return T;}此算法的时间复杂度关键在于嵌套的两个 for 循环,时间复杂度为O(m*num),和矩阵的列数以及⾮ 0 元素的个数的乘积成正⽐,如果稀疏矩阵的⾮ 0 元素很多的情况,使⽤这个算法,虽然⼀定程度上节省了空间,但是时间复杂度会很⾼。

三元组表示稀疏矩阵的转置(一般算法和快速算法)

三元组表示稀疏矩阵的转置(一般算法和快速算法)

一、设计要求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 模块设计程序包括两个模块:主程序模块、矩阵运算模块。

稀疏矩阵转置+快速转置

稀疏矩阵转置+快速转置

稀疏矩阵转置+快速转置稀疏矩阵转置Description稀疏矩阵的存储不宜⽤⼆维数组存储每个元素,那样的话会浪费很多的存储空间。

所以可以使⽤⼀个⼀维数组存储其中的⾮零元素。

这个⼀维数组的元素类型是⼀个三元组,由⾮零元素在该稀疏矩阵中的位置(⾏号和列号对)以及该元组的值构成。

矩阵转置就是将矩阵⾏和列上的元素对换。

现在就请你对⼀个稀疏矩阵进⾏转置。

以下是稀疏矩阵转置的算法描述:图:稀疏矩阵转置的算法描述Input输⼊的第⼀⾏是两个整数r和c(r*c <= 12500),分别表⽰⼀个包含很多0的稀疏矩阵的⾏数和列数。

接下来有r⾏,每⾏有c个整数,表⽰这个稀疏矩阵的各个元素。

Output输出c⾏,每⾏有r个整数,每个整数后跟⼀个空格。

该结果为输⼊稀疏矩阵的转置矩阵。

Sample Input6 70 12 9 0 0 0 00 0 0 0 0 0 0-3 0 0 0 0 14 00 0 24 0 0 0 00 18 0 0 0 0 015 0 0 -7 0 0 0Sample Output0 0 -3 0 0 1512 0 0 0 18 09 0 0 24 0 00 0 0 0 0 -70 0 0 0 0 00 0 14 0 0 00 0 0 0 0 0HINT提⽰:严⽼师纸质书中⽤union类型来表⽰稀疏矩阵类型,这是有问题的,应该使⽤struct来表⽰该类型。

注意理解为什么转置算法中,以列从⼩到⼤来进⾏转置。

实际上只需⼀个循环就能够完成转置⽽不需将列从⼩到⼤来处理,转置后的矩阵虽然是正确的但却乱掉了,以⾄于在各种处理中会增加复杂。

(其实就本题⽽⾔,如果不以列从⼩到⼤处理将导致输出困难,输出的复杂度增加)总结:矩阵是⼀个应⽤很⼴泛的⼯具和课题。

看看《⿊客帝国》就知道了。

现在初步给⼤家介绍矩阵的操作,以后有机会还会详细讨论矩阵的。

1 #include <stdio.h>2 #include <string.h>3 #include <iostream>4 #include <string>5 #include <math.h>6 #include <algorithm>7 #include <vector>8 #include <stack>9 #include <queue>10 #include <set>11 #include <map>12 #include <math.h>13const int INF=0x3f3f3f3f;14 typedef long long LL;15const int mod=1e9+7;16const int maxn=1e4+10;17using namespace std;1819 typedef struct20 {21int row;22int col;23int val;24 }Triple;2526 typedef struct27 {28 Triple date[maxn];29int rows;30int cols;31int nums;32 }TSMatrix;3334void TransposeTSMatrix(TSMatrix *A,TSMatrix *B)35 {36 B->rows=A->cols;37 B->cols=A->rows;38 B->nums=A->nums;39if(B->nums > 0)40 {41int cnt=0;42for(int i=1;i<=A->cols;i++)43 {44for(int j=1;j<=A->nums;j++)45 {46if(A->date[j].col==i)47 {48 cnt++;49 B->date[cnt].row=A->date[j].col;50 B->date[cnt].col=A->date[j].row;51 B->date[cnt].val=A->date[j].val;52 }53 }54if(cnt == B->nums)55break;56 }57 }58return ;59 }6061int main()62 {63 TSMatrix A,B;64 scanf("%d %d",&A.rows,&A.cols);65 A.nums=0;66for(int i=1;i<=A.rows;i++)67 {68for(int j=1;j<=A.cols;j++)69 {70int x;71 scanf("%d",&x);72if(x)73 {74 A.nums++;75 A.date[A.nums].row=i;76 A.date[A.nums].col=j;77 A.date[A.nums].val=x;78 }79 }80 }81 TransposeTSMatrix(&A,&B);82int cnt=1;83for(int i=1;i<=B.rows;i++)84 {85for(int j=1;j<=B.cols;j++)86 {87int a,b;88 a=B.date[cnt].row;89 b=B.date[cnt].col;90if(a==i&&b==j)91 {92 printf("%d ",B.date[cnt].val);93 cnt++;94 }95else96 printf("%d ",0);97 }98 printf("\n");99 }100return0;101 }稀疏矩阵快速转置Description稀疏矩阵的存储不宜⽤⼆维数组存储每个元素,那样的话会浪费很多的存储空间。

数据结构-稀疏矩阵的三元组表存储方法

数据结构-稀疏矩阵的三元组表存储方法

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

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置
scanf("%d",&M.data[i].i);
getchar();
}
printf("输入该非零元的列数:");
scanf("%d",&M.data[i].j);
getchar();
while(M.data[i].j>M.mn||M.data[i].j<1)
{
printf("输入的列数不合法\n请重新输入列数:");
scanf("%d",&M.data[i].e);
getchar();
printf("输入该非零元的行数:");
scanf("%d",&M.data[i].i);
getchar();
while(M.data[i].i>M.mu||M.data[i].i<1)
{
printf("输入的行数不合法\n请重新输入行数:");
scanf("%d",&M.mu);
getchar();
printf("\nmn=");
scanf("%d",&M.mn);
getchar();
printf("\ntu=");
scanf("%d",&M.tu);
getchar();
if(M.tu>maxsize)
{
printf("非零元个数已超过定义的值\n请重新输入tu=");if(M.daa[k].j==i){
T.data[j].e=M.data[k].e;

基于三元组表表示的稀疏矩阵的快速转置算法及其改进

基于三元组表表示的稀疏矩阵的快速转置算法及其改进

基于三元组表表示的稀疏矩阵的快速转置算法及其改进摘要:介绍基于三元组表表示的稀疏矩阵的快速转置算法,此算法在转置前需要先确定原矩阵中各列第一个非零元在转置矩阵中的位置,在此使用2个数组作为辅助空间,为了减少算法所需的辅助空间,通过引入2个简单变量提出一种改进算法。

该改进算法在时间复杂度保持不变的情况下,空间复杂度比原算法节省一半。

需求分析:矩阵作为许多科学与工程计算的数据对象,必然是计算机处理的数据对象之一。

在实际应用中,常会遇到一些阶数很高,同时又有许多值相同的元素或零元素的矩阵,在这类矩阵中,如果值相同的元素或零元素在矩阵中的分配没有规律,则称之为稀疏矩阵。

为了节省存储空间,常对稀疏矩阵进行压缩存储。

压缩存储的基本思想就是:对多个值相同的元素只分配1个存储空间,对零元素不分配存储空间。

换句话说,就是只存储稀疏矩阵中的非零元素。

稀疏矩阵可以采取不同的压缩存储方法,对于不同的压缩存储方法,矩阵运算的实现也就不同。

1.稀疏矩阵的三元组表表示法根据压缩存储的基本思想,这里只存储稀疏矩阵中的非零元素,因此,除了存储非零元的值以外,还必须同时记下它所在行和列的位置(i,j),即矩阵中的1个非零元aij由1个三元组(i,j,aij)惟一确定。

由此可知,稀疏矩阵可由表示非零元的三元组表及其行列数惟一确定。

对于稀疏矩阵的三元组表采取不同的组织方法即可得到稀疏矩阵的不同压缩存储方法,用三元组数组(三元组顺序表)来表示稀疏矩阵即为稀疏矩阵的三元组表表示法。

三元组数组中的元素按照三元组对应的矩阵元素在原矩阵中的位置,以行优先的顺序依次存放。

三元组表的类型说明如下:# define MAXSIZE 1000 /*非零元素的个数最多为1000*/typedef struct{int row,col; /*该非零元素的行下标和列下标*/ElementType e; /*该非零元素的值*/}Triple;typedef struct{Triple data[MAXSIZE+1]; /*非零元素的三元组表,data[0]未用*/int m,n,len; /*矩阵的行数、列数和非零元素的个数*/}TSMatrix;2.稀疏矩阵的快速转置算法待转置矩阵source和转置后矩阵dest分别用三元组表A和B表示,依次按三元组表A中三元组的次序进行转置,转置后直接放到三元组表B的正确位置上。

三元组顺序表实现矩阵的转置

三元组顺序表实现矩阵的转置

三元组顺序表实现矩阵的转置:/*------------------------------------------------------------------------------用三元组顺序表实现对稀疏矩阵的转置-----------------------------------------编译环境:VS 2013--------------------------------------------------------------------------------------*/#define_CRT_SECURE_NO_WARNINGS//用于取消VS 2013对printf、scanf等函数的警告#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef int ElemType;typedef struct{int i;int j;ElemType e;}tupletype;typedef struct{int rownum;int colnum;int nznum;tupletype data[MAXSIZE];}table;void creatable(table *M); //用户输入,创建一个三元组表void trans(table *M, table *T); //转置void show(table *M); //以矩阵形式输出三元组表int main(){table M, T;creatable(&M);system("cls");puts("矩阵M:");show(&M);trans(&M, &T);puts("矩阵M的转置矩阵T:");show(&T);return 0;}void creatable(table *M){int row, col, i, j, nz;ElemType e;printf("请输入矩阵M的行、列、非零元素个数(中间用逗号隔开):");scanf("%d,%d,%d", &row, &col, &nz);M->rownum = row;M->colnum = col;M->nznum = 0;while (M->nznum < nz){printf("请输入依次输入矩阵M中非零元素的行标(1~%d)、列标(1~%d)和元素值:", row, col);scanf("%d,%d,%d", &i, &j, &e);if (e != 0){M->data[M->nznum].i = i - 1;M->data[M->nznum].j = j - 1;M->data[M->nznum].e = e;M->nznum++;}}}void trans(table *M, table *T){int col, b, q = 0;T->rownum = M->colnum;T->colnum = M->rownum;T->nznum = M->nznum;if (T->nznum != 0){for (col = 0; col < M->colnum; col++){for (b = 0; b < M->nznum; b++){if (M->data[b].j == col){T->data[q].i = M->data[b].j;T->data[q].j = M->data[b].i;T->data[q].e = M->data[b].e;q++;}}}}}void show(table *M){int i, j, k, e;for (i = 0; i < M->rownum; i++){for (j = 0; j < M->colnum; j++){e = 0;for (k = 0; k < M->nznum; k++){if (i == M->data[k].i && j == M->data[k].j){e = M->data[k].e;break;}}printf("%4d", e);}printf("\n\n");}}程序运行结果图:。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置#include<>
#include<>
#include<>
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INEEASLIBE -1
#define OVERFLOW -2
#define maxsize 100
typedef int status;
typedef int elemtype;
typedef struct
{
int i,j;
elemtype e;
}elem;
typedef struct
{
elem data[maxsize+1];
int mu,mn,tu;
}matrix;
status showmatrix(matrix M)
{
int i,j,k=1;
for(i=1;i<=;i++)
{
for(j=1;j<=;j++)
{
if(i==[k].i&&j==[k].j)
{
printf("%d\t",[k].e);
k++;
}
else
printf("0\t");
}
printf("\n");
}
return OK;
}
status trans(matrix M,matrix &T)
{
int i=1,j=1,k=1;
=;
=;
=;
while(i<=
for(;k<=;k++)
if[k].j==i)
{
[j].e=[k].e;
[j].i=[k].j;
[j].j=[k].i;
j++;
}
k=1;
i++;
}
return OK;
}
status initmatrix(matrix &M)
{
printf("请输入该矩阵行数mu和列数mn和非零元个数tu\nmu=");
scanf("%d",&;
getchar();
printf("\nmn=");
scanf("%d",&;
getchar();
printf("\ntu=");
scanf("%d",&;
getchar();
if>maxsize)
printf("非零元个数已超过定义的值\n请重新输入tu=");
scanf("%d",&;
getchar();
}
printf("请输入非零元和它所在的行数和列数(矩阵从先从左到右,再从上到下输入)\n");
for(int i=1;i<=;i++)
{
if(i==1)
printf("输入非零元:");
else
printf("输入下一个非零元:");
scanf("%d",&[i].e);
getchar();
printf("输入该非零元的行数:");
scanf("%d",&[i].i);
getchar();
while[i].i>||[i].i<1)
{
printf("输入的行数不合法\n请重新输入行数:");
scanf("%d",&[i].i);
getchar();
}
printf("输入该非零元的列数:");
scanf("%d",&[i].j);
getchar();
while[i].j>||[i].j<1)
{
printf("输入的列数不合法\n请重新输入列数:");
scanf("%d",&[i].j);
getchar();
}
}
return OK;
}
status fasttrans(matrix M,matrix &T)
{
=;
=;
=;
int *num,*pose;
num=(int*)malloc*sizeof(int));
pose=(int*)malloc*sizeof(int));
*(pose)=1;
int i=1;
for(;i<=;i++)
*(num+i-1)=0;
for(i=1;i<=;i++)
{
*(num+[i].j-1)=*(num+[i].j-1)+1;
}
for(i=2;i<=;i++)
{
*(pose+i-1)=*(pose+i-2)+*(num+i-2);
}
for(i=1;i<=;i++)
{
[*(pose+[i].j-1)].i=[i].j;
[*(pose+[i].j-1)].j=[i].i;
[*(pose+[i].j-1)].e=[i].e;
*(pose+[i].j-1)=*(pose+[i].j-1)+1;
}
return OK;
}
main()
{
matrix M,T;
char c;
while(1)
{
printf("1:初始化矩阵\n2:显示矩阵\n3:普通转置\n4:快速转置\n");
scanf("%c",&c);
getchar();
switch(c)
{
case '1':
if(initmatrix(M)==OK)
printf("初始化成功\n");
break;
case '2':
showmatrix(M);
break;
case '3':
trans(M,T);
printf("转置后矩阵为:\n");
showmatrix(T);
break;
case '4':
fasttrans(M,T);
printf("转置后矩阵为:\n");
showmatrix(T);
break;
default:
printf("输入不合法\n");
break;
}
}
}。

相关文档
最新文档