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

三元组表示稀疏矩阵的转置(一般算法和快速算法)一、设计要求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. 引言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)式中矩阵M的(5行6列共有)8个非零元素的三元组表示:
{ (1,1, 8), (1,3, 9) , (2,2,2) , (3,4,3) , (3,6,7) , (4,1,6) , (4,3,4) , (5,4,5)}
若以某种方式(以行为主或以列为主的顺序)将8个三元组排列起来,再加上一个表示矩阵M的行数,列数及非零元素的个数的特殊的三元组(5,6,8),则所形成的表就能唯一地确定稀疏矩阵。
5.快速转置算法程序:
void fastran(Spmatrix a,Spmatrix *b)
{ int k,p,q,col;
int num[10],pot[10];
b->m=a.n; b->n=a.m; b->t=a.t;
if (a.t!=0)
普通算法分析:按b.data中三元组的次序进行转置。也就是说,按照矩阵M的列序进行转置。显然,为了找到M中的每一列的所有的非零元素,需要对a.data从第1行起整个扫描一遍。由于a.data是以M的行序来存放每一个非零元素的,因此,这样得到的顺序恰好是b.data应有的顺序。其具体算法描述如下:
矩阵的转置运算是变换元素的位置,把位于(i, j)的元素换到(j, i)位置上。也就是说,把元素的行和列对换。所以一个m×n的矩阵M,它的转置矩阵是一个n×m的矩阵,且N[i,j]=M[j,i],其中,1≤i≤n,1≤j≤m。例如, (算式1)中的矩阵N就是矩阵M的转置矩阵,矩阵N也是一个稀疏矩阵,其非零元素的排列情况如表-1(b)所示。求矩阵M的转置矩阵N,实际上就是由表-1(a)求表-1(b)。
这比直接用二维数组表示矩阵的转置算法的时间量级O(m*n)要差。不难看出,此算法之所以耗费时间,问题在于其每形成转置矩阵的一行,都必须对a.data从头到尾扫描一遍。能否对a.data只扫描一次,又不引起元素的移动就能得到要求的b->data呢?为此,我们可使用另一种快速方法。
数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法《数据结构》实验报告◎实验题⽬:稀疏矩阵的转置、加法(⾏逻辑链接表)◎实验⽬的:学习使⽤三元组顺序表表⽰稀疏矩阵,并进⾏简单的运算◎实验内容:以三元组表表⽰稀疏矩阵,并进⾏稀疏矩阵的转置和加法运算。
⼀、需求分析该程序⽬的是为了⽤三元组表实现稀疏矩阵的转置和加法运算。
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中。
稀疏矩阵三元组实现矩阵转置算法实验报告

稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一.实习目的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。
三元组快速转置算法

三元组快速转置算法
三元组快速转置算法是一种用于将稀疏矩阵的三元组表示转置的算法。
稀疏矩阵是指大部分元素为0的矩阵,而三元组表示是一种常用的稀疏矩阵存储方式。
三元组表示将稀疏矩阵中非零元素的位置和对应的值存储起来,通常由三个数组来表示:行索引数组(row),列索引数组(col)和值数组(val)。
每个非零元素都有一个对应的行索引、列索引和值。
快速转置算法的基本思想是通过遍历三元组表示中的元素,将其按照列索引重新排序,并计算每个列索引在转置后的矩阵中的起始位置。
然后再遍历三元组表示,将每个元素插入到转置后相应的位置。
这样就完成了矩阵转置的过程。
具体实现快速转置算法的步骤如下:
1. 统计每个列索引出现的次数,得到每个列索引在转置后的矩阵中的起始位置。
2. 计算每个列索引在转置后的矩阵中的终止位置。
3. 根据起始位置和终止位置,确定每个非零元素在转置后的矩阵中的位置。
4. 将每个非零元素插入到转置后的矩阵中相应的位置。
快速转置算法的时间复杂度取决于稀疏矩阵中非零元素的个数和矩阵的维度。
相比于其他转置算法,快速转置算法在处理大规模稀疏矩阵时具有较高的效率。
需要注意的是,三元组表示和快速转置算法都是用于稀疏矩阵的
存储和操作,对于密集矩阵则没有优势。
数据结构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、稀疏矩阵A,B均采用三元组表示,验证实现矩阵A快速转置算法,设计并验证A,B相加得到矩阵C的算法。
(1)从键盘输入矩阵的行数和列数,随机生成稀疏矩阵。
(2)设计算法将随机生成的稀疏矩阵转换成三元组顺序表示形式存储。
(3)设计算法将快速转置得到的与相加得到的三元组顺序表分别转换成矩阵形式。
(4)输出随机生成的稀疏矩阵A,B及其三元组顺序表、快速转置得到的与相加得到的三元组顺序表及其矩阵形式。
二、实验过程及结果一、需求分析1、将随机生成的数定义为int型(为方便起见设定范围为-20至20(不含0),可修改),三元组存储的元素分别为非零元的行下标、列下标及该位置的元素值,零元不进行存储。
实际上在生成稀疏矩阵时是随机选取一些位置生成非零元然后存入三元组中。
2、从键盘输入矩阵的行数和列数后应能输出三元组顺序表及相应矩阵(按行和列排列形式输出)。
3、程序能实现的功能包括:①随机产生稀疏矩阵;②输出阵列形式的矩阵;③输出三元组顺序表;④将矩阵快速转置;⑤将两个稀疏矩阵相加生成新的矩阵。
二、概要设计1、稀疏矩阵的抽象数据类型定义:ADT TSMatrix{数据对象:D={ aij|i=1,2,…,m,j=1,2,…,n;Ai,j∈ElemSet,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}基本操作:CreateTSMatrix(&M)操作结果:创建矩阵MPrintTSMatrix(M)初始条件:矩阵M已存在操作结果:输出矩阵M中三元组形式的非零元素PrintTSMatrix1(M)初始条件:矩阵M已存在操作结果:以阵列形式输出矩阵UnZore(M, row, col)初始条件:矩阵M已存在操作结果:若位置(row,col)处存在非零元素,则返回该元素存储在矩阵中的序号TSMatrix_Add(M, N,&Q)初始条件:矩阵M,N已存在操作结果:将矩阵M,N相加得到Q并返回矩阵QFastTransposeSMatrix(M,&N)初始条件:矩阵M已存在操作结果:将矩阵M快速转置得到转置矩阵N并返回}ADT TSMatrix;⒊本程序模块结构⑴主函数模块void main(){初始化迷矩阵;创建矩阵并输出;将矩阵转置并输出;将矩阵相加并输出结果;}三、详细设计1、基本数据类型操作⑴typedef int ElemType;typedef struct{int i,j;ElemType e;}Triple;//数据类型三元组typedef struct{Triple data[maxsize+1];//矩阵大小int mu,nu,tu; //}TSMatrix;//矩阵抽象数据类型2、参数设置:#define maxsize 10000//----------基本操作的算法描述--------------------Status CreateTSMatrix(TSMatrix *M){//创建一个随机矩阵(data[0]未用)srand((int)time(NULL));printf("Please Input The Lines And Columns Of The Matrix:\n");printf("...(矩阵的期望规格大于4*5(或5*4))...\n");scanf(M->mu,M->nu);for(m=0;m<M->mu;m++){for(n=0;n<M->nu;n++){k[m][n]=rand()%20;if(k[m][n]==0){if(rand()%2)M->data[p].e=rand()%20+1;elseM->data[p].e=rand()%20-20;M->data[p].i=m+1;M->data[p].j=n+1;p++;}}}M->tu=p-1; //p从1开始,非零元个数刚好等于p-1return OK;}void PrintTSMatrix(TSMatrix M){//输出矩阵的三元组顺序表if(M.tu==0)printf("无非零元!\n");else{printf("该矩阵的行数为%d、列数为%d、非零元素个数为%d.\n非零元的坐标及值:\n\n",M.mu,M.nu,M.tu);printf(" 行列元素值\n");for(i=1;i<=M.tu;i++){printf("%4d%4d%6d\n",M.data[i].i,M.data[i].j,M.data[i].e);}printf("\n");}}void PrintTSMatrix1(TSMatrix M){//输出矩阵的阵列形式printf("阵列形式为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++)if (k<M.tu&&p->i==i&&p->j==j){printf("%4d",p->e); //data[0]未用,p从data[1]开始p++;k++;}elseprintf("%4d",0);printf("\n");}printf("\n");}int UnZore(TSMatrix M,int row,int col){while(order<=M.tu){if(M.data[order].i==row&&M.data[order].j==col)//order从1开始return order;order++;}return 0;}Status TSMatrix_Add(TSMatrix M,TSMatrix N,TSMatrix *Q){//矩阵相加得到新的矩阵,order从1开始if(M.mu==N.mu&&M.nu==N.nu){for(row=1;row<=M.mu;row++){for(col=1;col<=M.nu;col++){order1=UnZore(M,row,col);order2=UnZore(N,row,col);if(order1&&order2){Q->data[order].i=row;Q->data[order].j=col;Q->data[order].e=M.data[order1].e+N.data[order2].e;order++;}else if(order1&&(!order2)){Q->data[order].e=M.data[order1].e;Q->data[order].i=M.data[order1].i;Q->data[order].j=M.data[order1].j;order++;}else if((!order1)&&order2){Q->data[order].e=N.data[order2].e;Q->data[order].i=N.data[order2].i;Q->data[order].j=N.data[order2].j;order++;}}}Q->mu=M.mu;Q->nu=M.nu;Q->tu=order-1;return OK;}else{printf("\n不是同型矩阵不能进行相加!\n");return ERROR;}}Status FastTransposeSMatrix(TSMatrix M,TSMatrix *N){//采用三元组顺序表存储表示,求稀疏矩阵M的转置矩阵NN->mu=M.nu;N->nu=M.mu;N->tu=M.tu;if(N->tu){for(i=1;i<=M.nu;++i)num[i]=0;for(t=1;t<=M.tu;++t)++num[M.data[t].j];//求M中每一列非零元个数 cpot[1]=1;//求第col列中第一个元素在b.data中的序号for(i=2;i<=M.nu;++i)cpot[i]=cpot[i-1]+num[i-1];for(p=1;p<=M.tu;++p){i=M.data[p].j;q=cpot[i];N->data[q].i=M.data[p].j;N->data[q].j=M.data[p].i;N->data[q].e=M.data[p].e;++cpot[i];}}return OK;}⑶主函数算法:void main(){TSMatrix A,A1,B,C;printf("矩阵A:\n");CreateTSMatrix(&A);PrintTSMatrix(A);PrintTSMatrix1(A);printf("由矩阵A转置得矩阵A1...\n");FastTransposeSMatrix(A,&A1);PrintTSMatrix(A1);PrintTSMatrix1(A1);printf("矩阵B:\n");CreateTSMatrix(&B);PrintTSMatrix(B);PrintTSMatrix1(B);printf("矩阵A加矩阵B得到矩阵C...\n");if(TSMatrix_Add(A,B,&C)){PrintTSMatrix(C);PrintTSMatrix1(C);}}四、调试分析1、三元组顺序表的输出顺序应该是先按行排序再按列排序,即行主序,依次输出。
数据结构---三元组顺序表------稀疏矩阵的转置和快速转置

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;
三元组表示稀疏矩阵转置

三元组表示稀疏矩阵转置
随着时代的进步,互联网已经深入到了我们的各个层面,其成功的关键之一就
在于数据处理技术。
稀疏矩阵转置是构成这一技术的基础之一,主要目的是改变二维矩阵的行和列。
这里要介绍的是一种特殊的“三元组表示稀疏矩阵转置”技术,它可以更加高效地将变换后的矩阵存储在硬盘上以便以后可以重用。
三元组表示稀疏矩阵转置处理的思路是,首先,将需要转置的稀疏矩阵以一个“非零元素”列表的形式读入,记为(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的正确位置上。
实验四稀疏矩阵三元组下转置

实验四、稀疏矩阵三元组下转置一、实验内容将稀疏矩阵中的每个非零元素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. 实现稀疏矩阵的转置算法,并对比传统转置算法和快速转置算法的性能。
4. 提高对数据结构中稀疏矩阵处理方法的理解和应用能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 20194. 稀疏矩阵存储结构:三元组三、实验原理矩阵转置是指将矩阵的行和列互换位置,得到的新矩阵称为原矩阵的转置矩阵。
对于稀疏矩阵,由于其非零元素较少,使用三元组表示方法可以有效地存储和操作稀疏矩阵。
四、实验内容1. 稀疏矩阵的三元组表示方法:定义三元组结构体,包括行号、列号和元素值。
2. 稀疏矩阵的输入:从文件中读取稀疏矩阵的三元组数据。
3. 稀疏矩阵的传统转置算法:按行优先顺序遍历原矩阵,将非零元素的三元组信息插入到转置矩阵的三元组中。
4. 稀疏矩阵的快速转置算法:利用行压缩技术,减少转置过程中的重复计算,提高算法效率。
5. 转置矩阵的输出:将转置矩阵的三元组信息按照矩阵形式输出。
五、实验步骤1. 定义三元组结构体:```cppstruct Triple {int i; // 行号int j; // 列号double e; // 元素值};```2. 创建稀疏矩阵:```cppvoid CreateSparseMatrix(Triple& data, int& m, int& n, int& tu) { // 从文件中读取稀疏矩阵的三元组数据// ...}```3. 传统转置算法:```cppvoid TransposeMatrix(Triple& data, int& m, int& n, int& tu) {Triple t[MAXSIZE];int k = 0;for (int i = 1; i <= m; ++i) {for (int j = 1; j <= n; ++j) {if (data[i].j == j) {t[k].i = data[i].j;t[k].j = data[i].i;t[k].e = data[i].e;++k;}}}// 将t复制到data中// ...}```4. 快速转置算法:```cppvoid FastTransposeMatrix(Triple& data, int& m, int& n, int& tu) { // 利用行压缩技术,减少转置过程中的重复计算// ...}```5. 输出转置矩阵:```cppvoid PrintMatrix(Triple& data, int& m, int& n, int& tu) {// 按矩阵形式输出转置矩阵的三元组信息// ...}```六、实验结果与分析1. 实验结果:通过实验,成功实现了稀疏矩阵的传统转置算法和快速转置算法,并验证了算法的正确性。
三元组结构实现稀疏矩阵转置算法的分析

三元组结构实现稀疏矩阵转置算法的分析文章简要叙述了稀疏矩阵压缩存储的三元组表示法及其基于此种结构的矩阵的转置运算。
探讨了基于三元组结构的矩阵转置算法的具体实现方法及其时空复杂度的问题。
【关键词】稀疏矩阵压缩存储三元组转置算法在一些特殊矩阵中,如对称矩阵和上下三角矩阵,非零元素一般都有明显的规律,从而都可以压缩到一维数组里面,然而,实际应用中经常会遇到这样一些矩阵,它们非零元素少,且分布不均匀,且没有明显的规律,称之为稀疏矩阵。
按照压缩存储的思想,只需存储矩阵中的非零元素。
为了便于存取和检索,一般在存储的时候必须带有合适的辅助信息,即同时记录下它所在的行列的位置等等。
在实际应用中,一般我们采取的是用三元组和十字链表两种表示方法来实现稀疏矩阵的存储及其运算。
稀疏矩阵在数值计算、电力系统的潮流计算、天气预报、工程分析计算等方面都有着大量的应用,不少实际问题都可以转化为对稀疏矩阵的计算问题。
了解稀疏矩阵的各种操作变得尤为重要。
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)。
转置矩阵实验报告

一、实验目的1. 理解矩阵转置的概念和性质。
2. 掌握矩阵转置的计算方法,包括普通矩阵和稀疏矩阵的转置。
3. 通过编程实现矩阵转置算法,并分析算法的复杂度。
4. 理解矩阵转置在数值计算中的应用。
二、实验原理矩阵转置是指将矩阵的行和列互换位置得到的新矩阵。
对于任意矩阵 \( A \) ,其转置矩阵记为 \( A^T \) 。
如果 \( A \) 是一个 \( m \times n \) 的矩阵,那么 \( A^T \) 是一个 \( n \times m \) 的矩阵。
三、实验内容1. 普通矩阵转置- 使用二维数组存储矩阵,实现普通矩阵的转置。
- 输入一个 \( m \times n \) 的矩阵,输出其转置矩阵 \( A^T \) 。
2. 稀疏矩阵转置- 使用三元组表示稀疏矩阵,实现稀疏矩阵的转置。
- 输入一个稀疏矩阵,输出其转置矩阵 \( A^T \) 。
3. 算法分析- 分析普通矩阵转置和稀疏矩阵转置算法的时间复杂度。
- 比较两种算法在处理不同类型矩阵时的效率。
四、实验步骤1. 普通矩阵转置- 定义一个二维数组 \( A \) 存储矩阵元素。
- 输入矩阵 \( A \) 的行数 \( m \) 和列数 \( n \) 。
- 输入矩阵 \( A \) 的元素。
- 遍历数组 \( A \),将元素 \( A[i][j] \) 放入新数组 \( A^T[j][i] \) 。
- 输出转置矩阵 \( A^T \) 。
2. 稀疏矩阵转置- 定义一个结构体存储三元组,包括行号、列号和元素值。
- 输入稀疏矩阵的非零元素个数 \( t \) ,行数 \( m \) 和列数 \( n \) 。
- 输入稀疏矩阵的三元组表示。
- 遍历三元组表,将每个三元组 \( (i, j, e) \) 改为 \( (j, i, e) \) 。
- 输出转置矩阵 \( A^T \) 的三元组表示。
3. 算法分析- 普通矩阵转置的时间复杂度为 \( O(mn) \) ,空间复杂度为 \( O(mn) \) 。
用三元组表存储表示,求稀疏矩阵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类型。
三元组表实现矩阵的装置副本

三元组表实现矩阵的装置副本#include<stdio.h>#include<malloc.h>#define MaxSize 100typedef int DataType; int z=0;typedef struct{int x,y;DataType v;}TriTupleNode;typedef struct{TriTupleNode data[MaxSize];int m,n,t;}TriTupleTable;TriTupleTable* InitList(TriTupleTable*L) //初始化* { L=(TriTupleTable*)malloc(sizeof(TriTupleTable)); return L;}void Enter(TriTupleTable*s) {int i=0,j,a,c=0,flag;for(i;i<s->m;i++){for(j=0;j<s->n;j++){flag=1;for(a=0;a<z;a++){if(s->data[a].x==i+1 && s->data[a].y==j+1){printf(" %d ",s->data[a].v);flag=0;}}if(flag) printf(" %d ",c);}printf("\n");}}TriTupleTable* CreateList(TriTupleTable*L,int c) //建立{int n;L->m =L->n=L->t=0;for(n=0;n<c;n++){printf("〖输入你要创建数组元素的行、列、值。
〗");scanf("%d%d%d",&L->data[n].x,&L->data[n].y,&L->data[n].v); if(L->m < L->data[n].x) L->m=L->data[n].x;if(L->n < L->data[n].y) L->n=L->data[n].y;if(L->data[n].v!=0) L->t++;z++;}printf("〖输入结束,共输入了%d个数。
三元组顺序表实现矩阵的转置

三元组顺序表实现矩阵的转置:/*------------------------------------------------------------------------------用三元组顺序表实现对稀疏矩阵的转置-----------------------------------------编译环境: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");}}程序运行结果图:。
用三元组存储系数矩阵并转置

关于中秋节的小学生日记600字5篇八月十五中秋节。
此夜,人们仰望天空如玉如盘的朗朗明月,自然会期盼家人团聚,所以,中秋节又称“团圆节”。
橙子整理了关于中秋节的小学生日记600字5篇,欢迎借鉴参考。
关于中秋节的小学生日记600字一今年的中秋节与往年的不一样,今年的中秋月与往年的不一般。
你看,那皎洁的月亮如同一面明镜,照亮了我们每一个人的心……今年中秋节,我们全家是在海拔两千多米的神农架山顶上度过的。
我们晚上八点多才开车到达山顶,山顶上的温度很低,我们把带来的全部衣服都穿上了,但还是很冷,直到吃完饭,大家才想起来今天还是中秋节呢,一路上的疲惫顿时消失得无影无踪,我们叫嚷着跑出门外,啊!月亮是那样的圆、是那样的明亮、是那样的皎洁,好像在等我们呢。
月亮向大地挥洒着银光,把大山、树林、小溪都蒙上了一层银白色的面纱,隐隐约约可以看见大山的轮廓。
忽然,一片云雾遮住了月亮,今天晚上月亮可不想让乌云抢它的风头,所以它使劲地挤呀挤呀,想钻出来,这时,风娃娃要助月亮一一臂之力,吹了一口气,乌云被吓跑了,月亮又重新露出了它秀丽的脸蛋,像小姑娘撩去披在肩上的乌发,向人们露出了笑脸。
我看得入了迷,此刻,我的心完全被月亮夺去了,似乎那高高的山峰、潺潺的小溪、浓密的树林顿时都显得黯然无光了,就连那团团的云彩也好像刹那间消失了……星星眨1 / 6着它那小小的眼睛,忽明忽暗,可爱极了!啊!真美呀!夜空好像一条无比宽大的毯子,满天的星星像一颗颗珍珠缀在毯子上,明亮的月亮像一块宝石,闪闪发光。
“明月几时有,把酒问青天?”妈妈激动地禁不住背起诗来,我也不甘示弱“不知天上宫阙,今夕是何年?”“要不咱们来个古诗大比拼,不过,必须说与月亮有关的。
”叔叔提了一句,“好!”我们全部赞成。
“海上生明月,天涯共此时”“小时不识月,呼作白玉盘”……大家你说一句,我说一句,真是争先恐后、互不相让呀,我们吵得热火朝天,感觉也不太冷了,直到10点多,我们才停止了古诗大赛,我们又照了几张月亮的照片,叔叔还给我照了一张手托月亮的特写照呢。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
三元组顺序表实现矩阵的转置:
/*--------------------------------------------------------------
----------------用三元组顺序表实现对稀疏矩阵的转置-----------------
------------------------编译环境:VS 2013------------------------
--------------------------------------------------------------*/
#define_CRT_SECURE_NO_WARNINGS//用于取消VS 2013对printf、scanf等函数的警告#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef 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");
}
}
程序运行结果图:。