稀疏矩阵的快速转置

稀疏矩阵的快速转置
稀疏矩阵的快速转置

实验名称:实现稀疏矩阵的基本运算一、实验目的:

熟悉数组的有关概念,掌握稀疏矩阵的三元组存储结构及其基本运算算法。

二、实验内容:

键盘任意输入一个稀疏矩阵A(m*n),采用三元组存储方法求其转置矩阵B (n*m),并用快速转置算法实现该操作。

三、算法思想与算法描述:

为了确定相应位置,转置前必须求得稀疏矩阵A的三元组中每列非零元的个数,从而求得每列的第一个非零元在转置矩阵B的三元组中(行)的位置。为此需要两个辅助数组num和cpot,num[col]表示矩阵A的第col列中非零元的个数,cpot[col]矩阵A的第col列的第一个非零元在矩阵B中的恰当位置,且显然有:cpot[1]=1; cpot[col]= cpot[col-1]+ num[col-1] 2≤ col≤ A的列

四、实验步骤与算法实现:

#include

#include

#include

typedef int ElemType;

int a,b;

#define MaxSize 100

typedef struct{

int i;

int j;

ElemType d;

}TupNode;

typedef struct{

int mu;

int nu;

int tu;

TupNode data[MaxSize];

}TSMatrix;

TSMatrix *creatarray(TSMatrix *M){

int m,n,p=1;

int c;

printf("请输入数组 A:\n");

for(m=1;m<=a;m++)

for(n=1;n<=b;n++){

scanf("%d",&c);

if(c!=0){

M->data[p].d=c;

M->data[p].i=m;

M->data[p].j=n;

p++;

}

}

M->tu=p;

M->mu=a;

M->nu=b;

printf("原来的三元组为:\n");

for(m=1;m<=M->tu;m++)

printf("%3d%3d%3d\t",M->data[m].i,M->data[m].j,M->data[m].d);

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].d=M->data[p].d;

++cpot[col];

}

}

printf("\n\n装之后的三元组为:\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].d);

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].d;

p++;

}

else

d=0;

printf("%6d",d);

}

}

}

void main(){

TSMatrix *M;

TSMatrix *T;

M=(TSMatrix *)malloc(sizeof(TSMatrix));

T=(TSMatrix *)malloc(sizeof(TSMatrix));

printf("请输入行和列:\n");

scanf("%d%d",&a,&b);

M=creatarray(M);

printf("请输入数组内容:\n");

print(M,a,b);

T=fasttrans(M,T);

printf("数组内容为:\n");

print(T,b,a);

getchar();

}

五、实验测试及结果:

请输入行和列:

4 5

请输入数组A:

1 0 1 3 3

0 0 2 1 0

0 3 1 0 0

0 0 4 0 1

原来三元组的表示为:

1 1 1 1 3 1 1 4 3 1 5 3

2

3 2

2 4 1

3 2 3 3 3 1

4 3 4 4

5 1

请输入数组内容:

1 0 1 3 3

0 0 2 1 0

0 3 1 0 0

0 0 4 0 1

六.总结与体会:

稀疏矩阵的快速转置方法是预先确定好被转置矩阵的每一列的第一个非零元在转置后的目标矩阵三元组中的应有位置。通过此方法,我又熟悉了矩阵的转置和对三元组深刻的了解。

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

一、设计要求 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 模块设计 程序包括两个模块:主程序模块、矩阵运算模块。 3.2 系统子程序及其功能设计 系统共设置了8个子程序,各子程序的函数名及功能说明如下。 (1)CreateSMatrix(RLSMatrix &M) //创建稀疏矩阵 (2)void DestroySMatrix(RLSMatrix &M) //销毁稀疏矩阵 (3)void PrinRLSMatrix(RLSMatrix M) //遍历稀疏矩阵 (4)void print(RLSMatrix A) //打印矩阵函数,输出以阵列形式表示的矩阵 (5)TransposeSMatrix(RLSMatrix M,RLSMatrix &T) //求稀疏矩阵的转置的一般算法(6)FastTransposeSMatrix(RLSMatrix M,RLSMatrix &T) //快速转置算法 (7)void showtip() //工作区函数,显示程序菜单 (8)void main() //主函数

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

《数据结构》实验报告 ◎实验题目:稀疏矩阵的转置、加法(行逻辑链接表) ◎实验目的:学习使用三元组顺序表表示稀疏矩阵,并进行简单的运算 ◎实验内容:以三元组表表示稀疏矩阵,并进行稀疏矩阵的转置和加法运算。 一、需求分析 该程序目的是为了用三元组表实现稀疏矩阵的转置和加法运算。 1、输入时都是以三元组表的形式输入; 2、输出时包含两种输出形式:运算后得到的三元组表和运算后得到的矩阵; 3、测试数据: (1)转置运算时输入三元组表:1 2 12 1 3 9 3 1 -3 3 6 14 4 3 24 5 2 18 6 1 15 6 4 -7 得到转置后的三元组表:1 3 -3 1 6 15 2 1 12 2 5 18 3 1 9 3 4 24 4 6 -7 6 3 14 (2)进行加法运算时先输入矩阵A(以三元组表形式):1 1 1 2 2 2 2 3 4 3 1 -4 输入矩阵B(以三元组表形式):1 3 -2 2 3 -5 3 1 8 3 2 -6 A与B的和矩阵以矩阵形式输出为:1 0 -2 0 2 -1 4 -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中。 2.本程序包含了两个模块: (1)头文件模块; 其中包括定义三元组表Triple和稀疏矩阵Matrix,以及创建矩阵void CreatMatrix(Matrix *m)和输出矩阵void PrintMatrix(Matrix m)两个函数; (2)主程序模块; 包括主函数main(),快速转置函数void FastTransposeMatrix(Matrix a,Matrix *b)和实现矩阵相加函数void AddMatrix(Matrix a,Matrix b,Matrix *c) (三) 详细设计 定义三元组和稀疏矩阵类型: typedef struct { int i,j; int e; }Triple; typedef struct { Triple data[MAXSIZE+1]; int mu,nu,tu; }Matrix; 创建头文件:“Matrix.h” void CreatMatrix(Matrix *m)//矩阵的初始化 { int p=1,a,b,c; printf("请输入矩阵的行数、列数、非零元的个数(数据用空格隔开):"); scanf("%d %d %d",&(*m).mu,&(*m).nu,&(*m).tu);

稀疏矩阵三元组存储转置后矩阵输出

#include #include #define MAXSIZE 1000 typedef int ElementType; typedef struct { int row,col; ElementType e; }Triple; typedef struct { Triple data[MAXSIZE+1]; int m,n,len; }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"); 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; 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); printf("\n"); }

稀疏矩阵的建立与转置

实验2 稀疏矩阵的建立与转置 一、实验目的 掌握特殊矩阵的存储和操作算法。 二、实验内容及问题描述 实现用三元组保存稀疏矩阵并实现矩阵转置的算法。 三、实验步骤 1. 定义稀疏矩阵的三元组形式的存储结构。 2. 实现三元组矩阵的传统转置算法。 3. 实现三元组矩阵的快速转置算法。 4. 输入矩阵非零元素,测试自己完成的算法。 四、程序流程图

五、概要设计 矩阵是很多的科学与工程计算中研究的数学对象。在此,我们感兴趣的是,从数学结构这门学科着眼,如何存储矩阵的元从而使矩阵的各种运算有效的进行。本来,用二维数组存储矩阵,在逻辑上意义是很明确的,也很容易理解,操作也很容易和方便。但是在数值分析中经常出现一些阶数很高的矩阵,同时,在矩阵中又有很多值相同或者都为零的元素,可以对这种矩阵进行压缩存储:对多个值相同的元素只分配一个存储空间;对零元素不分配空间。稀疏矩阵的定义是一个模糊的定义:即非零元个数较零元个数较少的矩阵。例如下图所示的矩阵 为一个稀疏矩阵。为了实现稀疏矩阵的这种存储结构,引入三元组这种数据结构。三元组的线性表顺存储形式如下图: 六、详细设计 sanyuanzu.h 头文件 #define max 100 typedef struct { int row,col; int e; }Triple;//定义三元组 typedef struct { Triple data[max]; int mu,nu,tu; }TSMatrix;///*定义三元组的稀疏矩阵*/ void creat( TSMatrix &M) ; void fasttrans(TSMatrix A,TSMatrix &B);

矩阵的运算及其运算规则

矩阵基本运算及应用 201700060牛晨晖 在数学中,矩阵是一个按照长方阵列排列的复数或实数集合。矩阵是高等代数学中的常见工具,也常见于统计分析等应用数学学科中。在物理学中,矩阵于电路学、力学、光学和量子物理中都有应用;计算机科学中,三维动画制作也需要用到矩阵。矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。在电力系统方面,矩阵知识已有广泛深入的应用,本文将在介绍矩阵基本运算和运算规则的基础上,简要介绍其在电力系统新能源领域建模方面的应用情况,并展望随机矩阵理论等相关知识与人工智能电力系统的紧密结合。 1矩阵的运算及其运算规则 1.1矩阵的加法与减法 1.1.1运算规则 设矩阵,, 则

简言之,两个矩阵相加减,即它们相同位置的元素相加减! 注意:只有对于两个行数、列数分别相等的矩阵(即同型矩阵),加减法运算才有意义,即加减运算是可行的. 1.1.2运算性质 满足交换律和结合律 交换律; 结合律. 1.2矩阵与数的乘法 1.2.1运算规则 数乘矩阵A,就是将数乘矩阵A中的每一个元素,记为或. 特别地,称称为的负矩阵. 1.2.2运算性质 满足结合律和分配律 结合律:(λμ)A=λ(μA);(λ+μ)A =λA+μA. 分配律:λ(A+B)=λA+λB.

已知两个矩阵 满足矩阵方程,求未知矩阵. 解由已知条件知 1.3矩阵与矩阵的乘法 1.3.1运算规则 设,,则A与B的乘积是这样一个矩阵: (1) 行数与(左矩阵)A相同,列数与(右矩阵)B相同,即 . (2) C的第行第列的元素由A的第行元素与B的第列元素对应相乘,再取乘积之和.

数据结构与算法 特殊矩阵和稀疏矩阵

常熟理工学院 《数据结构与算法》实验指导与报告书 _2017-2018_____学年第__1__ 学期 专业:物联网工程 实验名称:特殊矩阵和稀疏矩阵 实验地点: N6-210 指导教师:聂盼红 计算机科学与工程学院 2017

实验五特殊矩阵和稀疏矩阵 【实验目的】 1、掌握数组的结构类型(静态的内存空间配置);通过数组的引用下标转换成该数据在内存中的地址; 2、掌握对称矩阵的压缩存储表示; 3、掌握稀疏矩阵的压缩存储-三元组表表示,以及稀疏矩阵的转置算法。 【实验学时】 2学时 【实验预习】 回答以下问题: 1、什么是对称矩阵?写出对称矩阵压缩存储sa[k]与aij之间的对应关系。 若n阶矩阵A中的元素满足下述性质:a ij=a ji,则称为n阶对称矩阵。 sa[k]与矩阵元素a ij之间存在着一一对应的关系: 若i>=j,k=i*(i+1)/2+j; 若i

的关系。(注意C程序中,i,j,k均从0开始) (2)调试程序与运行。对称矩阵存储下三角部分即i>=j。 对称矩阵为3,9,1,4,7 9,5,2,5,8 1,2,5,2,4 4,5,2,1,7 7,8,4,7,9 参考程序如下: #include<> #define N 5 int main() { int upper[N][N]= {{3,9,1,4,7}, {9,5,2,5,8}, {1,2,5,2,4}, {4,5,2,1,7}, {7,8,4,7,9} }; /*对称矩阵*/ int rowMajor[15]; /*存储转换数据后以行为主的数组*/ int Index; /*数组的索引值*/ int i,j; printf("Two dimensional upper triangular array:\n"); for (i=0; i

c++课程设计-矩阵的转置与乘法计算

c++课程设计-矩阵的转置与乘法计算

C++课程设计实验报告 姓名学号班级 任课教师时间 9月 教师指定题目4-4 矩阵的转置与乘法计算评定难易级别 A 实验报告成绩 1.实验内容: 1.1 程序功能介绍 该程序定义了一个向量类,里面的元素是模板形式,定义了有关向量了类的各种属性、方法及运算符重载函数。 1.2 程序设计要求 (1)利用已知的向量类对象定义一个矩阵类,矩阵类的数据是向量子对象,同样定义矩阵类的各种属性、方法及运算符重载函数。 (2)完善成员函数,使矩阵可以由文件输入,具体的输入格式自己规定。 (3)完成矩阵的赋值、转置、乘法等运算,要求用整形矩阵和浮点型矩阵分别演算。 (4)更改main函数结构,可由用户选择输入矩阵数据的方法,程序可以连续运行,直到选择退出为止。

2. 源程序结构流程框图与说明(含新增子函数的结构框图)

作者:喻皓学号:0511590125

3. 基本数据结构 定义的类模板,将函数用链表将一些功能函数连接起来。其中定义了构造函数,析构函数,重载赋值、乘法、数乘、输入、输出,矩阵转置等函数,实现矩阵的矩阵的赋值、转置、乘法等运算。 template class CMatrix { struct node { Vector **f;//**************************************组成矩阵的向量指针 int refcnt;//*************************************************被引用次数 int length;//*************************************************矩阵的行数 T **tmppointer;//*******************************************头指针类型} *p; public: // Vector ** begin() const {return p->f;}; CMatrix();//****************************************************默认的构造 CMatrix(int xsize,int ysize,T init=0);//***************************构造函数 CMatrix(int xlength,const Vector *vec);//************************构造函

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

数据结构---三元组顺序表------稀疏矩阵的转置和快速转置 #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();

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

基于三元组表表示的稀疏矩阵的快速转置算法及其改进 摘要:介绍基于三元组表表示的稀疏矩阵的快速转置算法,此算法在转置前需要先确定原矩阵中各列第一个非零元在转置矩阵中的位置,在此使用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每一行中非零元素的个 数)。

稀疏矩阵(算法与数据结构课程设计)

稀疏矩阵 一、问题描述 假若在n m ?阶中,有t 个元素不为零,令n m t ?=δ称为矩阵的稀疏因子。通常认为≤δ0.05时称为稀疏矩阵。稀疏矩阵的研究大大的减少了数据在计算机中存储所需的空间,然而,它们的运算却与普通矩阵有所差异。通过本次实验实现稀疏矩阵的转置、加法和乘法等多种运算。 二、基本要求 1、稀疏矩阵采用三元组表示,建立稀疏矩阵,并能按矩阵和三元组方式输出; 2、编写算法,完成稀疏矩阵的转置操作; 3、编写算法,完成对两个具有相同行列数的稀疏矩阵进行求和操作; 4、编写算法,对前一矩阵行数与后一矩阵列数相等的两个矩阵,完成两个稀疏矩阵的相乘操作。 三、测试数据 1、转置操作的测试数据: ??????? ? ?00200013000010020100 2、相加操作的测试数据: ??????? ? ?002000130000100 20100 ??????? ??00200010000210030300 3、相乘操作的测试数据: ?????? ? ??000000030040 0021 ??????? ??001002000021 四、算法思想 1、三元组结构类型为Triple ,用i 表示元素的行,j 表示元素的列,e 表示元素值。稀疏矩阵的结构类型为TSMatrix ,用数组data[]表示三元组,mu 表示行数,nu 表示列数,tu 表示非零元个数。 2、稀疏矩阵转置的算法思想 将需要转置的矩阵a 所有元素存储在三元组表a.data 中,按照矩阵a 的列序来转置。

为了找到a的每一列中所有非零元素,需要对其三元组表a.data扫描一遍,由于a.data 是以a的行需序为主序来存放每个非零元的,由此得到的就是a的转置矩阵的三元组表,将其储存在b.data中。 3、稀疏矩阵相加的算法思想 比较满足条件(行数及列数都相同的两个矩阵)的两个稀疏矩阵中不为0的元素的行数及列数(即i与j),将i与j都相等的前后两个元素值e相加,保持i,j不变储存在新的三元组中,不等的则分别储存在此新三元组中。最后得到的这个新三元组表就是两个矩阵的和矩阵的三元组表。 4、稀疏矩阵相乘的算法思想 两个相乘的矩阵为M与N,对M中每个元素M.data[p](p=1,2,…,M.tu),找到N中所有满足条件M.data[p].j=N.data[q].i的元素N.data[q],求得M.data[p].v和N.data[q].v 的乘积,又T(i,j)=∑M(i,k)×N(k,j),乘积矩阵T中每个元素的值是个累计和,这个乘积M.data[p].v×N.data[q].v只是T[i][j]中的一部分。为便于操作,应对每个元素设一累计和的变量,其初值是零,然后扫描数组M,求得相应元素的乘积并累加到适当的求累计和的变量上。由于T中元素的行号和M中元素的行号一致,又M中元素排列是以M的行序为主序的,由此可对T进行逐行处理,先求得累计求和的中间结果(T的一行),然后再压缩存储到Q.data中去。 五、模块划分 1、Status CreateM(TSMatrix *M, int a[],int row, int col),创立三元组; 2、void PrintM(TSMatrix M),按数组方式输出; 3、void PrintM3(TSMatrix M),按三元组方式输出; 4、Status TransposeSMatrix(TSMatrix M, TSMatrix *T),稀疏矩阵的转置; 5、Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q),稀疏矩阵加法; 6、Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q),稀疏矩阵相乘; 7、main(),主函数。 六、数据结构//(ADT) 1、三元组结构类型 typedef struct { int i,j; ElemType e; } Triple; 2、稀疏矩阵 typedef struct { Triple data[MAXSIZE+1];

矩阵转置及相加实验报告

一、实验内容和要求 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={|1≤i≤m, 1≤j≤n-1} Col ={|1≤i≤m-1, 1≤j≤n} 基本操作: CreateTSMatrix(&M) 操作结果:创建矩阵M PrintTSMatrix(M) 初始条件:矩阵M已存在 操作结果:输出矩阵M中三元组形式的非零元素 PrintTSMatrix1(M) 初始条件:矩阵M已存在 操作结果:以阵列形式输出矩阵 UnZore(M, row, col) 初始条件:矩阵M已存在 操作结果:若位置(row,col)处存在非零元素,则返回该元素存储在矩阵中的序号

稀疏矩阵的运算(完美版)

专业课程设计I报告(2011 / 2012 学年第二学期) 题目稀疏矩阵的转换 专业软件工程 学生姓名张鹏宇 班级学号 09003018 指导教师张卫丰 指导单位计算机学院软件工程系 日期 2012年6月18号

指导教师成绩评定表

附件: 稀疏矩阵的转换 一、课题内容和要求 1.问题描述 设计程序用十字链表实现稀疏矩阵的加、减、乘、转置。 2.需求分析 (1)设计函数建立稀疏矩阵,初始化值。 (2)设计函数输出稀疏矩阵的值。 (3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。 (4)构造函数进行两个稀疏矩阵相减,输出最终的稀疏矩阵。 (5)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。 (6)构造函数进行稀疏矩阵的转置,并输出结果。 (7)退出系统。 二、设计思路分析 (1)设计函数建立稀疏矩阵,初始化值。 (2)设计函数输出稀疏矩阵的值。 (3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。 (4)构造函数进行两个稀疏矩阵相减,输出最终的稀疏矩阵。 (5)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。 (6)构造函数进行稀疏矩阵的转置,并输出结果。 (7)退出系统。 三、概要设计 为了实现以上功能,可以从3个方面着手设计。 1.主界面设计 为了实现对稀疏矩阵的多种算法功能的管理,首先设计一个含有多个菜单项的主

控菜单子程序以链接系统的各项子功能,方便用户交互式使用本系统。本系统主控菜单运行界面如图所示。 2.存储结构设计 本系统采用单链表结构存储稀疏矩阵的具体信息。其中:全部结点的信息用头结点为指针数组的单链表存储。 3.系统功能设计 本系统除了要完成稀疏矩阵的初始化功能外还设置了4个子功能菜单。稀疏矩阵的初始化由函数i typedef int ElemType 实现。建立稀疏矩阵用void Creat()实现,依据读入的行数和列数以及非零元素的个数,分别设定每个非零元素的信息。4个子功能的设计描述如下。 (1)稀疏矩阵的加法: 此功能由函数void Xiangjia( )实现,当用户选择该功能,系统即提示用户初始化要进行加法的两个矩阵的信息。然后进行加法,最后输出结果。 (2)稀疏矩阵的乘法: 此功能由函数void Xiangcheng( )实现。当用户选择该功能,系统提示输

数据结构矩阵的转置

/* c1.h (程序名) */ #include #include #include /* malloc()等*/ #include /* INT_MAX等*/ #include /* EOF(=^Z或F6),NULL */ #include /* atoi() */ #include /* eof() */ #include /* floor(),ceil(),abs() */ #include /* exit() */ /* 函数结果状态代码*/ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 /* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ /* c5-2.h 稀疏矩阵的三元组顺序表存储表示*/ #define MAXSIZE 100 /* 非零元个数的最大值*/ typedef struct { int i,j; /* 行下标,列下标*/ ElemType e; /* 非零元素值*/ }Triple; typedef struct { Triple data[MAXSIZE+1]; /* 非零元三元组表,data[0]未用*/ int mu,nu,tu; /* 矩阵的行数、列数和非零元个数*/ }TSMatrix; /* bo5-2.c 三元组稀疏矩阵的基本操作,包括算法5.1(9个) */ Status CreateSMatrix(TSMatrix *M) { /* 创建稀疏矩阵M */ int i,m,n; ElemType e; Status k; printf("请输入矩阵的行数,列数,非零元素数:"); scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu); (*M).data[0].i=0; /* 为以下比较顺序做准备*/ for(i=1;i<=(*M).tu;i++)

稀疏矩阵快速转置

题目:假设稀疏矩阵A采用三元组表表示,编写程序实现该矩阵的快速转置 要求:输入一个稀疏矩阵A,由程序将其转换成三元组表存储;转置后的三元组表,由程序将其转换成矩阵形式后输出。 一、需求分析 1.用户可以根据自己的需求输入任意一个稀疏矩阵,通过程序将其转换成三元组存储方式; 2.并且能够完成矩阵的转置功能,要求需要使用的方法是快速转置的方法。 3.最后要够显示原矩阵和转置后的矩阵让用户能进行比较。 4.程序执行的命令包括: (1)构造稀疏矩阵M (2)求转转矩阵T (3)显示(打印)矩阵 二、概要设计 ⒈为实现上述算法,需要线性表的抽象数据类型: ADT SparseMatrix { 数据对象:D={a ij :|a ij ∈TermSet,i=1…m,m≥0,j=1…n,n≥0 m和n分别成为矩阵的行数和列数 } 数据关系:R={Row,Col} Row ={|1≤i≤m,1≤j≤n-1 } Col ={|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 SparseMatrix 2. 本程序有三个模块: ⑴主程序模块 main(){ 初始化; { 接受命令; 显示结果; }

稀疏矩阵的运算(完美版)

专业课程设计I报告( 2011 / 2012 学年第二学期) 题目稀疏矩阵的转换 专业软件工程 学生姓名张鹏宇 班级学号 09003018 指导教师张卫丰 指导单位计算机学院软件工程系 日期 2012年6月18号

指导教师成绩评定表

附件: 稀疏矩阵的转换 一、课题内容和要求 1.问题描述 设计程序用十字链表实现稀疏矩阵的加、减、乘、转置。 2.需求分析 (1)设计函数建立稀疏矩阵,初始化值。 (2)设计函数输出稀疏矩阵的值。 (3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。 (4)构造函数进行两个稀疏矩阵相减,输出最终的稀疏矩阵。 (5)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。 (6)构造函数进行稀疏矩阵的转置,并输出结果。 (7)退出系统。 二、设计思路分析 (1)设计函数建立稀疏矩阵,初始化值。 (2)设计函数输出稀疏矩阵的值。 (3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。 (4)构造函数进行两个稀疏矩阵相减,输出最终的稀疏矩阵。 (5)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。 (6)构造函数进行稀疏矩阵的转置,并输出结果。 (7)退出系统。 三、概要设计 为了实现以上功能,可以从3个方面着手设计。 1.主界面设计 为了实现对稀疏矩阵的多种算法功能的管理,首先设计一个含有多个菜单项的主控菜单子程序以链接系统的各项子功能,方便用户交互式使用本系统。本系统主控菜单运行界面如图所示。

2.存储结构设计 本系统采用单链表结构存储稀疏矩阵的具体信息。其中:全部结点的信息用头结点为指针数组的单链表存储。 3.系统功能设计 本系统除了要完成稀疏矩阵的初始化功能外还设置了4个子功能菜单。稀疏矩阵的初始化由函数i typedef int ElemType 实现。建立稀疏矩阵用void Creat()实现,依据读入的行数和列数以及非零元素的个数,分别设定每个非零元素的信息。4个子功能的设计描述如下。 (1)稀疏矩阵的加法: 此功能由函数void Xiangjia( )实现,当用户选择该功能,系统即提示用户初始化要进行加法的两个矩阵的信息。然后进行加法,最后输出结果。 (2)稀疏矩阵的乘法: 此功能由函数void Xiangcheng( )实现。当用户选择该功能,系统提示输入要进行相乘的两个矩阵的详细信息。然后进行相乘,最后得到结果。 (3)稀疏矩阵的转置: 此功能由函数void Zhuanzhi( )实现。当用户选择该功能,系统提示用户初始

用三元组表存储表示,求稀疏矩阵M转置函数T

实验目的 采用三元组表存储表示,求稀疏矩阵M转置函数T 实验内容 编程序并上机调试运行。 采用三元组表存储表示,求稀疏矩阵M转置函数T 编写程序 //采用三元组表存储表示,求稀疏矩阵M转置函数T #include #define MAXSIZE 100 typedef struct { int i,j; int e; }Triple; typedef struct { Triple data[MAXSIZE+1]; int mu,nu,tu; }TSMatrix; //创建稀疏矩阵M CreateSMatrix(TSMatrix *M) { int i,m,n,e,k; printf("输入矩阵M的行数、列数、非零元的个数(中间用逗号隔开):"); scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu); (*M).data[0].i=0; printf("\n"); for(i=1;i<=(*M).tu;i++) {

do { printf("输入第%d个非零元素所在的行(1~%d)列(1~%d)值以及该数值:",i,(*M).mu,(*M).nu); scanf("%d,%d,%d",&m,&n,&e); k=0; if(m<1||m>(*M).mu||n<1||n>(*M).nu) k=1; if(m<(*M).data[i-1].i||m==(*M).data[i-1].i&&n<(*M).data[i-1].j) k=1; }while(k); (*M).data[i].i=m; (*M).data[i].j=n; (*M).data[i].e=e; } printf("\n"); return 1; } //输出稀疏矩阵M void PrintSMatrix(TSMatrix M) { int i; printf("**************************************\n"); for(i=1;i<=M.tu;i++) printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e); printf("**************************************\n"); printf("\n"); } //求稀疏矩阵M的转置矩阵T void TransposeSMatrix(TSMatrix M,TSMatrix *T) { int p,q,col; (*T).mu=M.nu; (*T).nu=M.mu; (*T).tu=M.tu; if((*T).tu) { q=1; for(col=1;col<=M.nu;++col)

稀疏矩阵基本操作实验报告

稀疏矩阵基本操作实验报告 一、实验内容 稀疏矩阵的压缩储存结构,以及稀疏矩阵的三元组表表示方法下的转置、相加、相 乘等算法 二、实验目的 1. 熟悉数组、矩阵的定义和基本操作 2. 熟悉稀疏矩阵的储存方式和基本运算 3. 理解稀疏矩阵的三元组表类型定义,掌握稀疏矩阵的输入、输出和转置算法 三、实验原理 1. 使用三元组储存矩阵中的非零元素(三元组分别储存非零元素的行下标,列下标和 元素值)。除了三元组表本身,储存一个稀疏矩阵还需要额外的三个变量,分别储 存矩阵的非零元个数,矩阵的行数和矩阵的列数。 2. 稀疏矩阵的创建算法: 第一步:根据矩阵创建一个二维数组,表示原始矩阵 第二步:取出二维数组中的元素(从第一个元素开始取),判断取出元素是否为非零元素,如果为非零元素,把该非零元素的数值以及行下标和列下表储存到三元数 组表里,否则取出下一个元素,重复该步骤。 第三步:重复第二步,知道二维数组中所有的元素已经取出。 3. 稀疏矩阵倒置算法:

第一步:判断进行倒置的矩阵是否为空矩阵,如果是,则直接返回错误信息。 第二步:计算要倒置的矩阵每列非零元素的数量,存入到num 数组(其中num[i] 代表矩阵中第i 列非零元素的个数)。以及倒置后矩阵每行首非零元的位置,存入cpot 数组中(其中cpot 表示倒置后矩阵每行非零元的位置,对应表示原矩阵每列中第 一个非零元的位置)。 第三步:确定倒置后矩阵的行数和列数。 第四步:取出表示要导致矩阵中三元组表元素{e, I, j} (第一次取出第一个,依次取出下一个元素),从第二步cpot 数组中确定该元素倒置后存放的位置(cpot[j] ),把该元素的行下标和列下标倒置以后放入新表的指定位置中。cpot[j] 变量加一。 第五步:重复第四步,直到三元组表中所有的元素都完成倒置。 第六步:把完成倒置运算的三元组表输出。 4. 稀疏矩阵加法算法: 第一步:检查相加两个矩阵的行数和列数是否相同,如果相同,则进入第二步,否 则输出错误信息。 第二步:定义变量i 和j,用于控制三元组表的遍历。 第三步:比较变量矩阵M 中第i 个元素和矩阵N 中第j 个元素,如果两个元素是同一行元素,如果不是则进入第四步,如果是,再继续比较两个元素是否为同一列元 素,如果是,把两个元素值相加,放到三元组表中;否则把列下表小的元素依次放 到三元组表中。进入第五步 第四步:如果矩阵M 中第i 个元素的行下标大于矩阵N 中第j 个元素的行下标,则把矩阵N 中第j 个元素所在行的所有非零元素添加到三元组表中;如果矩阵M 中第

java稀疏矩阵快速转置

====实习报告二“稀疏矩阵快速转置”演示程序===== (一)、程序的功能和特点 1. 程序功能:三元组将稀疏矩阵的行号,列号和元素值作为三元组的三个元素进行存储,该程序实现对稀疏矩阵的顺序存储,并可以对该稀疏矩阵进行快速实现转置。 2. 程序特点:采用java面向对象语言。创建三元组存放稀疏矩阵。结合java 的语言特点,利用稀疏矩阵和三元组的存储特点,交换数组的行号和列号实现数组的快速转置。 (二)、程序的算法设计 算法一:“稀疏矩阵的快速转置方法”算法: 1.【逻辑结构与存储结构设计】 逻辑结构:线性结构。 存储结构:顺序存储结构。 行号row 列号col 元素值value 1 2 3 2.【基本操作设计】 因为A中第一列的第一个非零元素一定存储在B.data[1],如果还知道第一列的非零元素的个数,那么第二列的第一个非零元素在B.data中的位置便等于第一列的第一个非零元素在B.data中的位置加上第一列的非零元素的个数,如此类推,因为A中三元组的存放顺序是先行后列,对同一行来说,必定先遇到列号小的元素,这样只需扫描一遍A.data即可。 根据这个想法,需引入两个向量来实现:num[n+1]和cpot[n+1],num[col]表示矩阵A中第col列的非零元素的个数(为了方便均从1单元用起),cpot[col]初始值表示矩阵A中的第col列的第一个非零元素在B.data中的位置。于是cpot 的初始值为: cpot[1]=1; cpot[col]=cpot[col-1]+num[col-1]; 2≤col≤n 例如对于矩阵A的num 和cpot的值如下: Col 1 2 3 4 5 6 num[col] 2 1 1 2 0 1 cpot[col] 1 3 4 5 7 7 矩阵A的num与cpot值

相关文档
最新文档