基于三元组表表示的稀疏矩阵的快速转置算法及其改进
稀疏矩阵三元组快速转置（转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 问题描述稀疏矩阵是指那些多数元素为零的矩阵。
利用稀疏特点进行存储和计算可以大大节省存储空间，提高计算效率。
求一个稀疏矩阵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。
输出稀疏矩阵的三元组表的总结与反思
输出稀疏矩阵的三元组表的总结与反思
近年来，随着稀疏矩阵在计算机科学中的广泛应用，输出稀疏矩阵的三元组表成为了一种常见的数据结构。
三元组表是将稀疏矩阵以行、列、数值的形式存储在一个二维数组中，可以大大减少稀疏矩阵的存储空间，提高计算效率。
在输出稀疏矩阵的三元组表过程中，需要注意以下几点：
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的情况下，只有少数非零元素的情况。
数据结构稀疏矩阵的表示和转置
数据结构实验报告实验四稀疏矩阵的表示和转置一、实验目的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;}欢迎您的下载，资料仅供参考！致力为企业和个人提供合同协议，策划案计划书，学习课件等等打造全网一站式需求。
稀疏矩阵的存储和快速转置实验报告
福建工程学院课程设计课程：数据结构题目：稀疏矩阵的快速转置专业：运算机类班级：座号：姓名：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）回车显示的结果是：六、课程设计总结及心得体会：通过本次课程设计，我对有关稀疏矩阵及其三元组表的知识做了温习和巩固。
稀疏矩阵快速转置算法的分析与优化
稀疏矩阵快速转置算法的分析与优化
王敏
【期刊名称】《计算机应用与软件》
【年(卷),期】2010(27)8
【摘要】介绍稀疏矩阵的三元组表压缩存储方案时,提出了利用数组首下标元素存储稀疏矩阵总行数、总列数和非零元素总个数三方面信息的改进的存储定义方式.给出了基于新的定义结构上用C语言编写的快速转置算法,并通过对算法性能进行分析,提出了仅使用一个数组的两种改进的快速转置算法.经过对比两种改进算法的时间复杂度和空间复杂度,总结出既具有原快速转置算法时间复杂度低的优点,又降低了算法的空间复杂度的优化算法,达到了对原快速转置算法进行优化的目的.【总页数】4页(P72-74,85)
【作者】王敏
【作者单位】渭南师范学院计算机科学系,陕西,渭南,714000
【正文语种】中文
【相关文献】
1.稀疏矩阵快速转置算法的动态演示 [J], 司玲玲;石磊娜;王亚楠;王保民
2.基于三元组表表示的稀疏矩阵的快速转置算法及其改进 [J], 王荣
3.三元组结构实现稀疏矩阵转置算法的分析 [J], 刘建荣;喻涛;
4.基于伪地址存储结构的稀疏矩阵快速转置算法 [J], 任志国; 侯永艳
5.基于高频快速优化算法的舰船RCS分析 [J], 李敢; 祝泓; 邸瀚漪; 张韩西子
因版权原因，仅展示原文概要，查看原文内容请购买。
稀疏矩阵三元组实现矩阵转置算法实验报告
稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一．实习目的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。
稀疏矩阵的快速转置算法(c语言)详解
稀疏矩阵的快速转置算法（C语言）详解稀疏矩阵是指大部分元素为零的矩阵，只有少数元素为非零的矩阵。
在实际的计算机科学和工程应用中，稀疏矩阵经常出现，比如在图形图像处理、科学计算和数据分析等领域。
而稀疏矩阵的快速转置算法是针对稀疏矩阵的一种重要算法，它可以有效地将稀疏矩阵进行转置，从而方便后续的计算和操作。
快速转置算法的实现是计算机科学中一个经典的问题，对于稀疏矩阵来说更是如此。
在本文中，我们将从深度和广度两个方面对稀疏矩阵的快速转置算法进行全面评估，探讨其原理和实现细节，并对其进行详细解析。
让我们简要了解一下稀疏矩阵的结构和特点。
稀疏矩阵通常由三个部分组成：行数组、列数组和值数组。
行数组存储非零元素所在的行号，列数组存储非零元素所在的列号，而值数组则存储非零元素的值。
由于稀疏矩阵的特殊性，传统的矩阵转置算法并不适用于稀疏矩阵，因此需要设计一种特殊的快速转置算法来处理稀疏矩阵。
在对快速转置算法进行详细解析之前，让我们先来看一下转置操作的定义。
对于一个矩阵A，其转置矩阵记为A^T，即A的行与列互换。
在稀疏矩阵的转置操作中，我们需要将原始矩阵中的非零元素按照列索引进行重新排列，同时保持其在矩阵中的相对位置不变。
实现稀疏矩阵的快速转置算法涉及到矩阵的数据结构和算法设计方面的知识。
传统的方法是通过对每个非零元素进行遍历，并将其插入到新矩阵的相应位置中，但这种方法的时间复杂度较高。
而快速转置算法通过巧妙的数据结构设计和算法优化，可以在更短的时间内完成转置操作，提高了算法的效率。
在C语言中实现稀疏矩阵的快速转置算法需要考虑到内存管理、指针操作和数据结构的设计等方面。
通常情况下，可以使用链表等数据结构来表示稀疏矩阵，同时利用指针进行快速的遍历和操作。
在实际的编程过程中，还需要注意对内存的合理分配和释放，以避免内存泄漏和溢出的问题。
为了更好地理解稀疏矩阵的快速转置算法，我们可以通过具体的代码实现来加深对算法原理的理解。
三元组稀疏矩阵快速转置C语言算法
下面就是（算式 １）式中矩阵 Ｍ 的（５ 行 ６ 列共有）８ 个非零元 素的三元组表示：
四、快速转置算法
这两种算法的函数中，ａ 是已知的三元组表，为了使函数 得到转置后新的三元组表ｂ， 这里使用的是传址调用的形参＊ｂ。
按照 ａ．ｄａｔａ 中三元组的次序进行转置。转置后的元素 不连续存放，直接放到 ｂ－＞ｄａｔａ 中应有的位置上，这样既可 以避免元素移动，又只需对 ａ．ｄａｔａ 扫描一次。为了确定矩阵 Ｍ 中的每一列（即 Ｎ 中每一行）的第一个非零元素在 ｂ－＞ｄａｔａ 中 应有的位置，需要先求得矩阵 Ｍ 中的每一列中非零元素的个 数。为此，需设置两个数组 ｎｕｍ［１．．ｎ］和 ｐｏｔ［１．．ｎ］，分别存 放在矩阵 Ｍ 中每一列的非零元素个数和每一列第 １ 个非零元素 在 ｂ－＞ｄａｔａ 中的位置，即
二数组的三元组表示与稀疏矩阵在实际应用中往往会遇到一种大多数元素的值为零的矩阵只有少部分为非零元素这些非零元素在矩阵中的分布又没有一定的规?我们把它记作零元素个数非零元素个数即零元素个数远远大于非零元素个数
专业视窗
决策管理
Policy & Management
三元组稀疏矩阵快速转置 Ｃ 语言算法
徐光联
ｎｕｍ［ａ．ｄａｔａ［ｋ］．ｊ］）； ｝
ｐｏｔ［１］＝０； ｆｏｒ （ｃｏｌ＝２； ｃｏｌ＜＝ａ．ｎ； ｃｏｌ＋＋） ｛ ｐｏｔ［ｃｏｌ］＝ｐｏｔ［ｃｏｌ－１］＋ｎｕｍ［ｃｏｌ－１］； ｐｒｉｎｔｆ（＂ｐｏｔ［％ｄ］＝％ｄ＼ｎ＂，ｃｏｌ，ｐｏｔ［ｃｏｌ］）； ｝ ｆｏｒ （ｐ＝０；ｐ＜ａ．ｔ；ｐ＋＋） ｛ ｃｏｌ＝ａ．ｄａｔａ［ｐ］．ｊ； ｑ＝ｐｏｔ［ｃｏｌ］； ｂ－＞ｄａｔａ［ｑ］．ｉ＝ａ．ｄａｔａ［ｐ］．ｊ； ｂ－＞ｄａｔａ［ｑ］．ｊ＝ａ．ｄａｔａ［ｐ］．ｉ； ｆａｓｔｒａｎ （ ｂ－＞ｄａｔａ［ｑ］．ｖ＝ａ．ｄａｔａ［ｐ］．ｖ； ｐｏｔ［ｃｏｌ］＋＋；
三元组压缩存储结构的稀疏矩阵的运算快速转置
三元组压缩存储结构的稀疏矩阵的运算快速转置在计算机科学和数学领域中，稀疏矩阵是一种在大部分元素为零的矩阵。
由于其大部分元素为零，因此在存储和运算时存在着一些挑战。
为了解决这一问题，人们提出了三元组压缩存储结构，这种存储结构能够有效地压缩稀疏矩阵，并且能够实现快速的运算转置。
1.稀疏矩阵稀疏矩阵是一种大部分元素为零的矩阵，与之相对应的是稠密矩阵，其大部分元素为非零值。
稀疏矩阵通常在图像处理、文本处理、网络分析等领域中得到广泛应用。
然而，由于大部分元素为零，传统的存储方式会导致存储空间的浪费。
人们提出了三元组压缩存储结构，以解决稀疏矩阵存储的问题。
2.三元组压缩存储结构三元组压缩存储结构是一种用于表示稀疏矩阵的存储格式。
它采用三个数组来分别存储矩阵的非零元素的行坐标、列坐标和数值。
由于只需存储非零元素的信息，因此能够有效地压缩存储空间。
三元组压缩存储结构还能够实现快速的随机访问，这是由于它将矩阵的元素位置和数值分开存储，使得在进行运算时能够更为高效。
3.稀疏矩阵的运算稀疏矩阵的运算是对稀疏矩阵进行加法、减法、乘法等操作的过程。
在进行稀疏矩阵的运算时，三元组压缩存储结构能够显著提高计算效率。
这是由于在进行运算时，只需考虑非零元素，而无需考虑大量的零元素，从而减少了计算的复杂度。
4.稀疏矩阵的快速转置稀疏矩阵的转置是将矩阵的行和列交换，同时保持非零元素的位置和数值不变。
在传统的存储方式下，稀疏矩阵的转置操作相对复杂且耗时。
然而，采用三元组压缩存储结构后，稀疏矩阵的快速转置变得十分简便。
通过交换三元组中的行坐标和列坐标，即可完成稀疏矩阵的快速转置操作。
5.个人观点和理解我认为三元组压缩存储结构的出现，极大地解决了稀疏矩阵在存储和运算中的效率问题。
通过将矩阵的非零元素信息进行压缩存储，不仅节省了存储空间，同时也提高了计算效率。
在实际应用中，三元组压缩存储结构能够更好地满足对存储空间和计算效率有较高要求的场景，为稀疏矩阵的处理提供了更为便利和高效的途径。
实现稀疏矩阵采用三元组表示的基本运算实验报告
实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵（采用三元组表示）的基本运算实验报告一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:（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×n的稀疏矩阵，这三个数组的长度就是非零元素的个数。
三元组表示的稀疏矩阵在实际应用中具有以下特点：1.节省存储空间：由于只存储非零元素，因此可以大大减少存储空间的使用，尤其在元素总数远大于非零元素数目的情况下。
2.提高计算效率：对于稀疏矩阵，很多计算操作可以直接跳过零元素，只对非零元素进行计算，从而提高计算效率。
3.易于读取和修改：三元组表示使得读取和修改稀疏矩阵变得相对容易，因为只需要根据存储的三元组信息进行操作即可。
在实现三元组表示稀疏矩阵时，首先需要确定数据结构的形式。
一种常见的方式是使用类来表示三元组，其中类的成员变量分别对应非零元素的值、行号和列号。
这样每个实例对象代表一个非零元素。
另外，还可以使用数组来表示存储该矩阵所有的非零元素。
接下来是具体的实现步骤：1.初始化一个空的三元组数组，长度为非零元素的个数。
2.遍历整个稀疏矩阵，当遇到一个非零元素时，将其值、行号和列号分别存储到三元组数组中的对应位置。
3.结束遍历后，三元组数组中的每一个实例对象就代表一个非零元素。
4.根据实际应用的需要，可以在三元组数组中实现相应的操作，如查找指定位置的元素、修改元素的值等。
对于稀疏矩阵的三元组表示的实现，有以下几个注意点：1.非零元素的顺序：算法的效率与非零元素的顺序有关，可以对非零元素按行或列的顺序进行排序，这样可以提高一些查找操作的效率。
三元组表示稀疏矩阵转置
三元组表示稀疏矩阵转置
随着时代的进步，互联网已经深入到了我们的各个层面，其成功的关键之一就
在于数据处理技术。
稀疏矩阵转置是构成这一技术的基础之一，主要目的是改变二维矩阵的行和列。
这里要介绍的是一种特殊的“三元组表示稀疏矩阵转置”技术，它可以更加高效地将变换后的矩阵存储在硬盘上以便以后可以重用。
三元组表示稀疏矩阵转置处理的思路是，首先，将需要转置的稀疏矩阵以一个“非零元素”列表的形式读入，记为(row,col,data),其中row表示该非零元素所
处的行数，col表示列数，data表示该非零元素的值；然后，根据row和col的值，计算变换后的稀疏矩阵的最终坐标依次给出(col,row)；最后，将所有非零元素的
坐标以及对应的值，按照升序排序，用“三元组表示形式”写入硬盘中以作备份。
三元组表示稀疏矩阵转置也是一种特殊的“非零元素”列表构建技术。
它把矩
阵转换成一系列索引型(index type)的非零元素数据，这既可以更加有效地把变换后的矩阵存储起来，也可以有效地提高运算效率，避免无谓的存储和消耗。
从长远来看，三元组表示稀疏矩阵转置无疑是一种重要的数据技术，它的成功
不仅取决于它的有效简便度，而且取决于它有助于改善计算处理效率，提高输出效果，从而使数据技术更为可靠，有助于推动信息革命更大范围的发展。
基于三元组表表示的稀疏矩阵的快速转置算法及其改进
基于三元组表表示的稀疏矩阵的快速转置算法及其改进摘要:介绍基于三元组表表示的稀疏矩阵的快速转置算法,此算法在转置前需要先确定原矩阵中各列第一个非零元在转置矩阵中的位置,在此使用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的正确位置上。
三元组结构实现稀疏矩阵转置算法的分析
三元组结构实现稀疏矩阵转置算法的分析文章简要叙述了稀疏矩阵压缩存储的三元组表示法及其基于此种结构的矩阵的转置运算。
探讨了基于三元组结构的矩阵转置算法的具体实现方法及其时空复杂度的问题。
【关键词】稀疏矩阵压缩存储三元组转置算法在一些特殊矩阵中，如对称矩阵和上下三角矩阵，非零元素一般都有明显的规律，从而都可以压缩到一维数组里面，然而，实际应用中经常会遇到这样一些矩阵，它们非零元素少，且分布不均匀，且没有明显的规律，称之为稀疏矩阵。
按照压缩存储的思想，只需存储矩阵中的非零元素。
为了便于存取和检索，一般在存储的时候必须带有合适的辅助信息，即同时记录下它所在的行列的位置等等。
在实际应用中，一般我们采取的是用三元组和十字链表两种表示方法来实现稀疏矩阵的存储及其运算。
稀疏矩阵在数值计算、电力系统的潮流计算、天气预报、工程分析计算等方面都有着大量的应用，不少实际问题都可以转化为对稀疏矩阵的计算问题。
了解稀疏矩阵的各种操作变得尤为重要。
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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于三元组表表示的稀疏矩阵的快速转置算法及其改进
摘要:介绍基于三元组表表示的稀疏矩阵的快速转置算法,此算法在转置前需要先确定原矩阵中各列第一个非零元在转置矩阵中的位置,在此使用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的正确位置上。
这种转置算法称为快速转置算法。
为了能将待转置三元组表A中元素一次定位到三元组表B的正确位置上,需要预先计算以下数据:
1)待转置矩阵source每一列中非零元素的个数(即转置后矩阵dest每一行中非零元素的个
数)。
2)待转置矩阵source每一列中第一个非零元素在三元组表B中的正确位置(即转置后矩阵
dest每一行中第一个非零元素在三元组表B中的正确位置)。
为此,需要设2个数组num[]和position[],其中num[col]用来存放矩阵source中第col列中非零元素个数(转置后矩阵dest中第col行非零元素的个数);position[col]用来存放转置矩阵source中第col列(转置后矩阵dest中第col行)中第一个非零元素在三元组表B中的正确位置。
num[col]的计算方法:将三元组表A扫描一遍,对于其中列号为k的元素,给相应的num[k]加1。
position[col]的计算方法:
position[1]=1
position[col]=position[col-1]+num[col-1]
(其中2[col[A.n)
将三元组表A中所有的非零元素直接放到三元组表B中正确位置上的方法是:position[col]的初值为三元组表A中列号为col(三元组表B的行号为col)的第1个非零元素的正确位置,当三元组表A中列号为col的1个元素加入到三元组表B时,则position[col]=position[col]+1,即:使position[col]始终指向三元组表A中列号为col的下一个非零元素在三元组表B
中的正确位置。
稀疏矩阵的快速转置算法如下:
(1)初始化num[ ]数组;
(2)求num[ ]数组各元素的值;
(3)求position[ ]数组各元素的值;
(4)将三元组表A中所有的非零元素直接放到三元组表B中正确位置上。
快速转置算法的时间主要耗费在4个并列的单循环上,这4个并列的单循环分别执行了A.n,A.len,A.n-1,A.len次,因而总的时间复杂度为O(A.n)+O(A.len)+O(A.n)+O(A.len),即为O(A.n+A.len)。
当待转置矩阵source中非零元素个数接近于A.m*A.n时,其时间复杂度接近于经典算法的时间复杂度O(A.m*A.n)。
快速转置算法在空间耗费上除三元组表所占用的空间外,还需2个辅助向量空间,即num[1..A.n],position[1..A.n]。
可见,算法在时间上的节省,是以更多的存储空间为代价的。
可见,稀疏矩阵的三元组表表示法虽然节约了存储空间,但比起矩阵的正常存储方式来讲,其实现相同操作要耗费较多的时间,同时也增加了算法的难度,即以
耗费更多时间为代价来换取空间的节省。
3. 稀疏矩阵的快速转置算法的改进
在稀疏矩阵的快速转置算法中引入2个辅助向量空间num[]和position[],在下面的改进算法中只保留num[],另外引入2个变量k1和k2。
num[col]起初用来存放矩阵source中第col列中非零元素个数(转置后矩阵dest中第col行非零元素的个数),然后通过修改num[col]中各元素的值,用num[col]存放转置矩阵source中第col列(转置后矩阵dest中第col行)中第一个非零元素在三元组表B中的正确位置。
修改num[col]中各元素的值的操作实现如下:
(1)令k1=num[1];num[1]=1;
(2)对于col=2,A.n依次做:
k2= num[col]
num[col]=k1+num[col-1];
k1=k2;
在转置过程中,当三元组表A中列号为col的1个元素加入到三元组表B时,则num[col]=num[col]+1,即:使num[col]始终指向三元组表A中列号为col的下一个非零元素在
三元组表B中的正确位置。
改进的快速转置算法如下:初始化num[ ]数组;求num[ ]数组各元素的值;修改num[ ]数组各元素的值;将三元组表A中所有的非零元素直接放到三元组表B中正确位置上。
显然,上述改进算法的时间复杂度与原算法相同,在空间复杂度上除了三元组表所占用的空间外,只需要1个辅助向量空间num[1..A.n]和2个简单变量,而算法的空间复杂度仅考虑算法所需的辅助空间,因此,改进算法的空间复杂度比原算法节约一半。