稀疏矩阵实验报告

合集下载

稀疏矩阵运算器实验报告

稀疏矩阵运算器实验报告
Ne=&N.data[N.tu]; // Ne指向矩阵N的非零元素尾地址
Qh=Qe=Q.data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址
while(Mp<=Me&&Np<=Ne)
{
Qe++;
switch(comp(Mp->i,Np->i))
{
case 1: *Qe=*Mp;
Mp++;
while(Mp<=Me)
{
Qe++;
*Qe=*Mp;
Mp++;
}
Q.tu=Qe-Qh; //矩阵Q的非零元素个数
return 1;
}
int MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q) {
//求矩阵乘积Q=M?N,采用行逻辑链接存储表示。
int arow,brow,p,q,t,ctemp[30],l,ccol,tp;
稀疏矩阵运算器
一:问题描述:
稀疏矩阵是指那些多数元素为零的矩阵。利用稀疏特点进行储存和计算可以大大节省储存空间,提高计算效率。实现一个能进行称稀疏矩阵基本运算的运算器。
基本要求:
以带逻辑链接信息的三元组顺序表表示稀疏矩阵,实现矩阵相加,相减,相乘的运算。稀疏矩阵的输入形式采用三元组表示。而运算结果的矩阵则用通常的阵列形式列出。
else t = N.tu+1;
for (q=N.rpos[brow]; q< t; ++q) {
ccol = N.data[q].j; //乘积元素在Q中列号
ctemp[ccol] += M.data[p].e * N.data[q].e;

稀疏矩阵(实验报告)

稀疏矩阵(实验报告)

《数据结构课程设计》实验报告一、实验目的:理解稀疏矩阵的加法运算,掌握稀疏矩阵的存储方法,即顺序存储的方式,利用顺序存储的特点——每一个元素都有一个直接前驱和一个直接后继,完成相关的操作。

二、内容与设计思想:1、设计思想1)主界面的设计定义两个矩阵a= 0 0 3 0 0 0 0 0 b= 0 2 0 0 0 0 0 00 0 0 0 0 0 5 0 0 0 0 4 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 6 0 00 0 0 0 7 0 0 0 0 0 0 0 8 0 0 00 0 0 0 0 0 0 0 0 0 1 0 0 0 0 00 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0定义两个数组A和B,用于存储矩阵a和矩阵b的值;定义一个数组C,用于存放数组A 和数组B相加后的结果。

2)实现方式稀疏矩阵的存储比较浪费空间,所以我们可以定义两个数组A、B,采用压缩存储的方式来对上面的两个矩阵进行存储。

具体的方法是,将非零元素的值和它所在的行号、列号作为一个结点存放在一起,这就唯一确定一个非零元素的三元组(i、j、v)。

将表示稀疏矩阵的非零元素的三元组按行优先的顺序排列,则得到一个其结点均为三元组的线性表。

即:以一维数组顺序存放非零元素的行号、列号和数值,行号-1作为结束标志。

例如,上面的矩阵a,利用数组A存储后内容为:A[0]=0,A[1]=2, A[2]=3, A[3]=1, A[4]=6, A[5]=5, A[6]=3, A[7]=4, A[8]=7, A[9]=5, A[10]=1, A[11]=9, A[12]=-1同理,用数组B存储矩阵b的值。

2、主要数据结构稀疏矩阵的转存算法:void CreateMatrix(int A[m][n],int B[50]){int i,j,k=0;for(i=0;i<m;i++)for(j=0;j<n;j++)if(A[i][j]!=0){B[k]=i;k++;B[k]=j;k++;B[k]=A[i][j];k++;}B[k]=-1;}稀疏矩阵的加法实现:3、主要算法结构分析:1)void CreateMatrix(int A[m][n],int B[50]),这是一个将稀疏矩阵转存的函数,类似于顺序存储三元组表。

稀疏矩阵数据结构实验报告

稀疏矩阵数据结构实验报告

目录1.需求分析 (1)2.概要设计 (2)2.1链表对稀疏矩阵进行定义 (2)2.3程序一共有五个功能 (2)3.详细设计 (3)3.1稀疏矩阵存储算法分析 (3)3.2稀疏矩阵各运算算法分析 (3)4.调试分析 (8)4.1调试过程中的问题及解决方法 (8)4.2算法的时间复杂度和空间复杂 (8)4.3经验和体会 (8)5.用户使用说明 (9)6.测试结果 (10)6.1程序主界面 (10)6.2其他函数操作界面显示 (10)参考文献 (15)致谢 (16)1.需求分析矩阵在日常生活中应用广泛,尤其是有些特殊矩阵的运算。

但是在实际应用中有一种矩阵,在m×n的矩阵中有t个非零元素,且t远小于m×n,我们这样的矩阵被称为稀疏矩阵。

由于这类矩阵中通常零元素是没有规律的,为了能够找到相应的元素,仅存储非零元素的值是不行的,还要存储其所在的行和列等信息。

本程序主要的任务是创建稀疏矩阵,并且利用C++算法程序实现相应的运算(转置,加法,减法,乘法)(1)输入的形式以及范围:键盘输入符合要求的稀疏矩阵。

(2)输出形式:最终运算结果以矩阵的形式输出。

(3)程序功能实现:输入矩阵通过程序运算出相应的转置矩阵以及两个符合要求的矩阵的加减乘除法的运算。

(4)测试数据:如果输入正确,程序会显示最后的运算结果;否则错误时则会返回上层。

2.概要设计要存储稀疏矩阵并且进行运算,那么就要了解稀疏矩阵的存储结构,这里采用链表的形式存储稀疏矩阵并进行运算。

2.1链表对稀疏矩阵进行定义typedef struct OLNode{ // 定义链表元素int i,j;int e;struct OLNode *next; // 该非零元所在行表和列表的后继元素}OLNode,*OLink;typedef struct{ // 定义链表对象结构体OLink *head; //头指针int mu,nu,tu; // 行数,列数,和非零元素个数}CrossList;2.3程序一共有五个功能1.用CreateSMatrix_OL(M)函数来实现稀疏矩阵的存储,用OutPutSMatrix_OL(M)函数实现稀疏矩阵的输出。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算实验目的:1.学习并理解稀疏矩阵的概念、特点以及存储方式。

2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。

3.实现稀疏矩阵加法、乘法的算法,并进行性能测试和分析。

实验原理:稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。

在实际问题中,有许多矩阵具有稀疏性,例如文本矩阵、图像矩阵等。

由于存储稀疏矩阵时,对于大量的零元素进行存储是一种浪费空间的行为,因此需要采用一种特殊的存储方式。

常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。

其中,三元组顺序表是最简单直观的一种方式,它是将非零元素按行优先的顺序存储起来,每个元素由三个参数组成:行号、列号和元素值。

此外,还需要记录稀疏矩阵的行数、列数和非零元素个数。

稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历,对于相同位置的元素进行相加,得到结果矩阵。

稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算,即行乘以列的和。

实验步骤:1.实现稀疏矩阵的三元组顺序表存储方式,并完成稀疏矩阵的初始化、转置、打印等基本操作。

2.实现稀疏矩阵的加法运算,并进行性能测试和分析。

3.实现稀疏矩阵的乘法运算,并进行性能测试和分析。

4.编写实验报告。

实验结果:经过实验测试,稀疏矩阵的加法和乘法算法都能正确运行,并且在处理稀疏矩阵时能够有效节省存储空间。

性能测试结果表明,稀疏矩阵加法、乘法的运行时间与非零元素个数有关,当非零元素个数较少时,运算速度较快;当非零元素个数较多时,运算速度较慢。

实验分析:稀疏矩阵的运算相对于普通矩阵的运算有明显的优势,可以节省存储空间和运算时间。

在实际应用中,稀疏矩阵的存储方式和运算算法都可以进行优化。

例如,可以采用行逻辑链接表的方式存储稀疏矩阵,进一步减少存储空间的占用;可以采用并行计算的策略加快稀疏矩阵的运算速度。

总结:通过本次实验,我深入学习了稀疏矩阵的概念、特点和存储方式,掌握了稀疏矩阵加法、乘法的基本思想和算法,并通过实验实现了稀疏矩阵的加法、乘法运算。

稀疏矩阵编程实验报告

稀疏矩阵编程实验报告

一、实验目的1. 理解稀疏矩阵的概念及其存储方式。

2. 掌握稀疏矩阵的基本操作,包括转置、加法、减法和乘法。

3. 通过编程实践,提高对数据结构和算法的理解和应用能力。

二、实验环境1. 编程语言:C语言2. 开发环境:Visual Studio 20193. 操作系统:Windows 10三、实验内容1. 稀疏矩阵的三元组表示及其实现2. 稀疏矩阵的转置3. 稀疏矩阵的加法、减法和乘法四、实验步骤1. 稀疏矩阵的三元组表示及其实现(1)定义稀疏矩阵的三元组结构体:```ctypedef struct {int row; // 行号int col; // 列号double val; // 非零元素值} Triple;```(2)定义稀疏矩阵结构体:typedef struct {int rows; // 矩阵行数int cols; // 矩阵列数int nums; // 非零元素个数Triple data; // 非零元素的三元组数组} SparseMatrix;```(3)编写函数实现稀疏矩阵的创建:```cvoid createSparseMatrix(SparseMatrix sm, int rows, int cols, int nums) { sm->rows = rows;sm->cols = cols;sm->nums = nums;sm->data = (Triple )malloc(nums sizeof(Triple));}```(4)编写函数实现稀疏矩阵的销毁:```cvoid destroySparseMatrix(SparseMatrix sm) {free(sm->data);sm->data = NULL;}2. 稀疏矩阵的转置(1)编写函数实现稀疏矩阵的转置:```cvoid transposeSparseMatrix(SparseMatrix src, SparseMatrix dst) {dst->rows = src->cols;dst->cols = src->rows;dst->nums = src->nums;dst->data = (Triple )malloc(src->nums sizeof(Triple));for (int i = 0; i < src->nums; i++) {dst->data[i].row = src->data[i].col;dst->data[i].col = src->data[i].row;dst->data[i].val = src->data[i].val;}}```3. 稀疏矩阵的加法、减法和乘法(1)编写函数实现稀疏矩阵的加法:```cvoid addSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val + sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val += sm2->data[j].val;}}}}}```(2)编写函数实现稀疏矩阵的减法:```cvoid subSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val - sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val -= sm2->data[j].val;}}}}}```(3)编写函数实现稀疏矩阵的乘法:```cvoid mulSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm2->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].col == sm2->data[j].row) {double sum = 0;for (int k = 0; k < sm1->nums; k++) {if (sm1->data[k].col == sm2->data[j].row) {sum += sm1->data[k].val sm2->data[j].val;}}if (sum != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val = sum;}}}}}```五、实验结果与分析1. 通过编程实现稀疏矩阵的基本操作,验证了算法的正确性。

稀疏矩阵实验报告

稀疏矩阵实验报告

稀疏矩阵基本操作班级:计算机科学与技术(2)班小组成员:日期:2012年4月17日1.需求分析【实验目的】熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现,及利用高级程序设计语言中已存在的数据类型来说明新的结构,用已经实现的操作来组合新的操作,具体实现细节则依赖于所用的语言的功能。

通过本次实习还可以帮助读者复习高级语言的使用方法。

掌握数组的特点及基本操作,如存储、输出、乘积、转置等,,以便在实际问题背景下灵活应用。

【基本要求】1.用C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。

2.概要设计栈的抽象数据类型ADT Matrix {数据对象:D={aij| i=1,2,…,m;j=1,2,…,n;ai∈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}基本操作:CreatSMatrix(&M)操作结果:构造一个稀疏矩阵。

Destroy SMatix (&M)初始条件:稀疏矩阵M已存在。

操作结果:销毁稀疏矩阵M。

PrintSMtrix(&M)初始条件:稀疏矩阵已存在。

操作结果:输出稀疏矩阵M。

CompSMtrix(M,&T)初始条件:稀疏矩阵M已存在。

操作结果:由稀疏矩阵M复制得到T。

AddSMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数相等。

操作结果:求稀疏矩阵的和Q=M+N。

SubtMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数对应相等。

稀疏矩阵的转置实训报告

稀疏矩阵的转置实训报告

#### 一、实训背景稀疏矩阵在计算机科学和工程领域中有着广泛的应用,特别是在处理大规模数据时,由于其数据压缩的特性,可以显著降低存储空间和计算时间。

稀疏矩阵的转置是稀疏矩阵处理中的一个基本操作,对于理解稀疏矩阵的性质和进行后续的矩阵运算至关重要。

本实训旨在通过实现稀疏矩阵的转置功能,加深对稀疏矩阵数据结构和操作的理解。

#### 二、实训目标1. 理解稀疏矩阵的概念和特点。

2. 掌握稀疏矩阵的三元组表示方法。

3. 实现稀疏矩阵的转置操作。

4. 分析转置操作的算法复杂度。

5. 对比不同转置算法的性能。

#### 三、实训内容1. 稀疏矩阵的三元组表示稀疏矩阵的三元组表示法通过三元组(i, j, e)来存储非零元素,其中i和j分别表示行和列的索引,e表示对应的元素值。

这种方法能够有效地压缩存储空间。

2. 稀疏矩阵的转置稀疏矩阵的转置操作涉及到交换行和列的索引。

具体步骤如下:- 遍历原稀疏矩阵中的所有非零元素。

- 对于每个非零元素(i, j, e),将其存储为(j, i, e)并添加到转置矩阵中。

3. 算法实现使用C++语言实现稀疏矩阵的转置,主要包括以下步骤:- 定义稀疏矩阵的数据结构。

- 实现转置函数。

- 测试转置函数的正确性和效率。

4. 性能分析分析不同转置算法的时间复杂度和空间复杂度,对比不同实现方式的性能。

#### 四、实训过程1. 数据结构设计使用结构体来定义稀疏矩阵的三元组,包括行索引、列索引和元素值。

同时,定义一个数组来存储所有的三元组。

2. 转置函数实现实现一个转置函数,该函数接收一个稀疏矩阵的三元组数组,返回一个新的三元组数组,表示转置后的稀疏矩阵。

3. 测试编写测试代码,创建一个稀疏矩阵实例,调用转置函数,并验证转置后的矩阵是否正确。

4. 性能测试使用不同的稀疏矩阵实例进行性能测试,比较不同实现方式的效率。

#### 五、实训结果与分析1. 结果通过实训,成功实现了稀疏矩阵的转置功能,并验证了其正确性。

《数据结构 课程设计》稀疏矩阵实验报告

《数据结构 课程设计》稀疏矩阵实验报告

(2)稀疏矩阵的相加:
void MatrixAdd(int A[max],int B[max],int C[max]),这个函数用 于实现数组A和数组B的相加,并将其相加的结果存入数组C。这个函数 讨论了数组在相加的过程中的几种情况: a、 A数组和B数组的行相等且列相等,两者直接相加后存入数组C中。 if(A[i]==B[j]) { if(A[i+1]==B[j+1]) { C[k]=A[i]; C[k+1]=A[i+1]; C[k+2]=A[i+2]+B[j+2]; k=k+3; i=i+3; j=j+3; } } b、A的列小于B的列,将A的三个元素直接存入C中
2、 系统分析
稀疏矩阵的保存:以一位数组顺序存放非零元素的行号、列号和数 值,行号为-1作为结束符。以三个一维数组存放一个系数矩阵中的一个 非零元素,为零额元素则不保存。用一个二重循环来实现判断每个系数
矩阵的非零元素是否为零,不为零,就将其行列下标和其值存入一维数 组中 稀疏矩阵的相加:用循环来判断存储A何B稀疏矩阵的两个一维数组 中的行列下标是否相等和其大小关系。若相等,则将两个一维数组的第 三个元素的值相加存入新的数组C里,行列下标不变的存入进去;若A的 列小于B的列,则将A的三个元素直接存入C中;若B的列小于A的列,则 将B的三个元素村日C中;若A的行小于B的行,则将A的三个元素存入C 中;若A的行大于B的行,则将B存入C中。
3、 概要设计
(1)主界面的设计:
定义两个矩阵a= 0 0 0 0 0 0 0 0 0 0 0 9 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 b= 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 1 0 0 4 0 0 0 0 0 0 0 8 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

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

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

稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵的压缩储存结构,以及稀疏矩阵的三元组表表示方法下的转置、相加、相乘等算法二、实验目的1.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义,掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素(三元组分别储存非零元素的行下标,列下标和元素值)。

除了三元组表本身,储存一个稀疏矩阵还需要额外的三个变量,分别储存矩阵的非零元个数,矩阵的行数和矩阵的列数。

2.稀疏矩阵的创建算法:第一步:根据矩阵创建一个二维数组,表示原始矩阵第二步:取出二维数组中的元素(从第一个元素开始取),判断取出元素是否为非零元素,如果为非零元素,把该非零元素的数值以及行下标和列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。

第三步:重复第二步,知道二维数组中所有的元素已经取出。

3.稀疏矩阵倒置算法:第一步:判断进行倒置的矩阵是否为空矩阵,如果是,则直接返回错误信息。

第二步:计算要倒置的矩阵每列非零元素的数量,存入到num数组(其中num[i] 代表矩阵中第i列非零元素的个数)。

以及倒置后矩阵每行首非零元的位置,存入cpot 数组中(其中cpot表示倒置后矩阵每行非零元的位置,对应表示原矩阵每列中第一个非零元的位置)。

第三步:确定倒置后矩阵的行数和列数。

第四步:取出表示要导致矩阵中三元组表元素{e, I, j}(第一次取出第一个,依次取出下一个元素),从第二步cpot数组中确定该元素倒置后存放的位置(cpot[j]),把该元素的行下标和列下标倒置以后放入新表的指定位置中。

cpot[j] 变量加一。

第五步:重复第四步,直到三元组表中所有的元素都完成倒置。

第六步:把完成倒置运算的三元组表输出。

4.稀疏矩阵加法算法:第一步:检查相加两个矩阵的行数和列数是否相同,如果相同,则进入第二步,否则输出错误信息。

第二步:定义变量i和j,用于控制三元组表的遍历。

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

数据结构课程设计实习报告题目:班级:学号:姓名:实习报告1.问题描述稀疏矩阵的操作基本功能要求:(1)稀疏矩阵采用三元组表示,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C。

(2)求出A的转置矩阵D,输出D。

2.设计1)设计思想矩阵中如果多数的元素没有数据,则会造成存储器空间的浪费,为此,必须设计稀疏矩阵的阵列储存方式,利用较少的存储器空间储存完整的矩阵数据。

但是这些存储空间的大部分存放的是0元素,从而造成大量的空间浪费.为了节省存储空间,可以只存储其中的非0元素. 对于矩阵Amn的每个元素aij,知道其行号i 和列号j就可以确定其位置.因此对于稀疏矩阵可以用一个结点来存储一个非0元素.该结点可以定义成: [i,j,aij]创建一个矩阵A和矩阵B,这两个稀疏矩阵具有相同行列数,然后矩阵A与矩阵B相加得到矩阵C,并输出C,稀疏矩阵采用三元组表示。

并调用原矩阵A 转置得到矩阵D,输出D。

2) 设计表示法(1) 函数调用关系如图所示。

3)实现注释:实现了原题中要求的:两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;得到矩阵A的转置矩阵D,输出D;稀疏矩阵均采用三元组表示。

3.调试报告调试程序时,应注意矩阵的调用。

比如,开始的时候没有注意将程序调用,最后尽管实现了矩阵的转置和相加,但没有符合题意。

题目要求的是用创建好的矩阵A和矩阵B进行相加,并对矩阵A进行转置,所以要调用好矩阵。

4.程序清单#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu; //mu、nu为稀疏矩阵的行列数,tu为稀疏矩阵的非零元素个数}TSMatrix;TSMatrix M,T,S,B,C;void CreateMatrix(TSMatrix &M){int i,elem,col,row,mu,nu,tu;printf("请输入稀疏矩阵的行数、列数和非零元素的个数:\n");scanf("%d%d%d",&mu,&nu,&tu);M.mu=mu;M.nu=nu;M.tu=tu;for (i=1;i<=tu;i++){printf("请输入非零元素的行号、列号和值:\n");scanf("%d%d%d",&col,&row,&elem);if ( mu<=1 || col>M.mu ||nu<=1 || row>M.nu){printf("error!");exit(0);}else{M.data[i].i=col; //输出这个三元组M.data[i].j=row;M.data[i].e=elem;}}}void FastTransposeSMatrix(TSMatrix M) /*求转置矩阵*/ {int num[100];int cpot[100];int p,q,t,col=0;T.mu=M.nu; // 给T的行、列数与非零元素个数赋值T.nu=M.mu;T.tu=M.tu;if(T.tu){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]++;}} TSMatrix(T);}void TSMatrix_add(TSMatrix M,TSMatrix T,TSMatrix &ADD) /*求矩阵的和*/ {int a=1,b=1,c=1,x;ADD.mu=M.mu;ADD.nu=M.nu;ADD.tu=0;for(x=1;x<=M.mu;x++){while(M.data[a].i==x&&T.data[b].i==x){if(M.data[a].j==T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e+T.data[b].e;c++;a++;b++;}else if(M.data[a].j<T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;}else{ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}while(M.data[a].i==x){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;while(T.data[b].i==x){ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}ADD.tu=c-1;}void ShowMatrix(TSMatrix &M) /*打印出矩阵*/ {int i=1,j=1,dir=1;//printf("稀疏矩阵为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++){if(M.data[dir].i==i && M.data[dir].j==j) {printf("%d ",M.data[dir].e);dir++;}elseprintf("0 ");}printf("\n");}void main(){while(1){int c;M.mu=0;M.nu=0;M.tu=0;printf("1.创建一个稀疏矩阵A:\n");printf("2.求转置矩阵A:\n");printf("3.创建一个稀疏矩阵B:\n");printf("4.求转置矩阵B:\n");printf("5.求A与B原矩阵的和:\n"); while (1){printf("请按键选择:");scanf("%d",&c);switch(c){case 1:CreateMatrix(M) ;break;case 2:FastTransposeSMatrix(M);printf("原矩阵A为:\n");ShowMatrix(M);printf("转置矩阵为:\n"); ShowMatrix(T);break;case 3:CreateMatrix(B) ;break;case 4:FastTransposeSMatrix(B);printf("原矩阵B为:\n");ShowMatrix(B);printf("转置矩阵为:\n");ShowMatrix(T);break;case 5:FastTransposeSMatrix(M);TSMatrix_add(M,B,S);printf("A与B原矩阵的和为:\n");ShowMatrix(S);break;return 0;}}}}5.结果分析(1)选择选项1,创建矩阵A;选择选项2,转置矩阵A。

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告

实现稀疏矩阵的基本运算实验报告实验报告:稀疏矩阵的基本运算实验一、引言稀疏矩阵是指在矩阵中大部分元素为0的情况下,只存储非零元素及其位置信息的数据结构。

由于稀疏矩阵节省空间,可以节约存储和计算时间,因此在科学计算和大规模矩阵运算中应用广泛。

本实验旨在实现稀疏矩阵的基本运算,包括矩阵加法、矩阵乘法和转置运算,并对其效率进行测试。

二、实验方法本实验使用C++语言实现稀疏矩阵的基本运算。

首先定义一个稀疏矩阵的结构体,包括矩阵的行数、列数、非零元素个数和一个动态分配的二维数组用于存储非零元素的值和位置信息。

然后根据实验要求,分别实现矩阵的加法、乘法和转置运算的函数。

1.矩阵加法:遍历两个矩阵的非零元素,将对应位置的元素相加存入结果矩阵。

2.矩阵乘法:遍历两个矩阵的非零元素,将对应位置的元素相乘并累加,存入结果矩阵。

3.转置运算:将矩阵的行列互换,同时调整非零元素的位置信息。

最后,通过随机生成不同大小的稀疏矩阵进行实验,并记录每种运算的运行时间,分析稀疏矩阵在不同运算中的效率差异。

三、实验结果1.矩阵加法运算:对两个1000*1000的稀疏矩阵进行加法运算,耗时0.05秒。

2.矩阵乘法运算:对一个1000*1000和一个1000*100的稀疏矩阵进行乘法运算,耗时0.1秒。

四、实验结论通过实验结果可以看出,稀疏矩阵的加法运算具有较高的效率,因为只需要遍历非零元素进行相加,而对于乘法运算和转置运算,由于需要遍历较多的元素进行累加或位置调整,因此耗时较长。

在矩阵转置运算中,由于矩阵规模较大,耗时最长。

总结而言,稀疏矩阵在处理大规模矩阵运算时具有一定的优势,可以节约存储空间和计算时间。

在实践中,可以根据应用的需求选择适当的数据结构和算法,进一步提升稀疏矩阵的运算效率。

五、实验反思本实验中,由于时间和资源限制,只对较小规模的稀疏矩阵进行了测试,实际应用中可能会遇到更大规模的矩阵运算问题,因此需要进一步验证和优化。

课程设计实验报告 稀疏矩阵应用

课程设计实验报告 稀疏矩阵应用

数据结构课程设计《数据结构》课程设计一.题目:稀疏矩阵应用(限1 人完成)要求:实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

(1)稀疏矩阵的存储(2)稀疏矩阵加法(3)矩阵乘法(4)矩阵转置二.算法思想描述:1.需求分析(1)设计函数建立稀疏矩阵,初始化值。

(2)设计函数输出稀疏矩阵的值。

(3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。

(4)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。

(5)构造函数进行稀疏矩阵的转置,并输出结果。

(6)退出系统。

1.算法概述:首先用两个结构体来定义十字链表元素:typedef struct OLNode{int i,j;int e;struct OLNode *right,*down;}OLNode,*OLink;OLNode结构为链表结点,i,j,e分别表示稀疏矩阵中元素的行,列和值。

typedef struct {int mu,nu,tu; //行数mu,列数nu,非零元素的个数tuOLink *rhead,*chead;}CrossList;CrossList结构用于连接起各个结点,mu,nu,tu分别表示整个矩阵的行数列数和非零元素的个数。

整个程序包含CreateSMatix_OL(用于创建十字链表),SMatrix_ADD(十字链表相加),ShowMAtrix(十字链表显示),MultSMatrix_OL(十字链表相乘),TurnSMatrix_OL(十字链表转置),DestroySMatrix_OL(十字链表销毁)六个函数。

CreateSMatix_OL的功能如下:首先输入稀疏矩阵的行数,列数,非零元素的个数,为*rhead和*chead分配内存空间,并将十字链表中节点初始化为NULL。

然后依次输入非零元素的行,列,值,以0 0 0为结尾结束链表的连接和while循环。

SMatrix_ADD 的功能如下:在初始化稀疏矩阵后选择十字链表相加会提示输入另一个稀疏矩阵,连接结束后SMatrix_ADD 函数以循环的方式比较非零元素是否为同一行列,如果是则两值相加,如果不是则把第二个元素加入链表中。

稀疏矩阵快速转置 数据结构实验报告

稀疏矩阵快速转置 数据结构实验报告

稀疏矩阵快速转置数据结构实验报告一、实验目的1、掌握稀疏矩阵的存储方式;2、掌握稀疏矩阵的快速转置算法;3、进一步了解和巩固线性表和链表的相关知识。

二、实验内容1、根据课本内容和参考资料,设计两种不同的存储稀疏矩阵的结构体,并分别实现稀疏矩阵的快速转置操作;2、实现输出稀疏矩阵、打印转置后的稀疏矩阵、以及转置前后两个稀疏矩阵在内存中的存储情况。

三、实验原理1、稀疏矩阵的存储稀疏矩阵指的是矩阵中绝大多数元素为零的矩阵,依据存储方式,目前主要有两种实现方法:顺序表和链表。

(1)顺序表顺序表的存储方式如下:typedef struct{int arr[MAXSIZE]; // 一维数组表示矩阵int rows; // 矩阵共有 rows 行int cols; // 矩阵共有 cols 列int nums; // 矩阵中不为零的元素共有 nums 个}TSMatrix;其中,数组 arr 的长度为 MAXSIZE,每个元素保存矩阵中某个元素的值,且元素的下标按行优先排列,例如,在一个5×5 的矩阵中,a23 可以表示成 a[(2-1)×5+3-1],其中 2-1 代表该元素所在行的下标,3-1 代表该元素所在列的下标。

(2)链表链式存储的特点在于元素之间存在指针联系,节点中保存三元组(row、col、val),其中 row 表示该元素所在的行,col 表示该元素所在的列,val 表示该元素的值,next 指针表示该元素的下一个节点。

2、稀疏矩阵转置稀疏矩阵转置的基本思想是将原矩阵中非零元素的行和列对换。

转置后的矩阵中行和列的值对应变换,对应的非零元素也跟着变化。

1、初始化转置矩阵;2、遍历原矩阵中的元素,将其转置后按行优先的顺序插入转置矩阵;3、输出转置矩阵。

链表转置的步骤如下:四、实验步骤1、根据上述原理,设计 2 种结构体 TSMatrix 和 LinkMatrix,分别完成快速转置算法;2、封装 tranverse_TMatrix 和 tranverse_LinkMatrix 两个函数,并设计测试用例验证结果。

数据结构-稀疏矩阵-实验报告与代码

数据结构-稀疏矩阵-实验报告与代码

一.需求分析输入要求:稀疏矩阵的行、列和非零元素个数输出要求:稀疏矩阵的转置、加法、减法、乘法二.算法设计本程序中采用的数据模型,用到的抽象数据类型的定义,程序的主要算法流程及各模块之间的层次调用关系1.抽象数据类型:ADT List {数据对象:D={ai:|ai∈ElemSet,i=1…n,n≥0}数据关系:R={Row,Col}Row={<ai,j,ai,j>|1<=i<=m,1<=j<=n-1}Col={<ai,j,ai,j>|1<=i<=m-1,1<=j<=n}基本操作:Status CreateSMatrix(TSMatrix &M)操作结果:初始化稀疏数组void PrintSMatrix(TSMatrix M)初始条件:稀疏数组M已经存在操作结果:打印矩阵Mvoid DestroySMatrix(TSMatrix &M)初始条件:稀疏数组M已经存在操作结果:销毁矩阵Mvoid CopySMatrix(TSMatrix M, TSMatrix &T)初始条件:稀疏数组M已经存在操作结果:复制矩阵M到TStatus AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M、N已经存在操作结果:求矩阵的和Q=M+NStatus SubSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M、N已经存在操作结果:求矩阵的差Q=M-NStatus TransposeSMatrix(TSMatrix M, TSMatrix & T)初始条件:稀疏数组M已经存在操作结果:求矩阵M的转置TStatus MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)初始条件:稀疏数组M已经存在操作结果:求矩阵的积Q=M*N}ADT List2. 本程序有二个模块:(1)主程序模块main(){初始化;{接受命令;显示结果;}}(2)三元组表单元模块:实现矩阵抽象数据类型。

稀疏矩阵 实验报告

稀疏矩阵 实验报告

#include <iostream>using namespace std;template <class T>struct element{int row,col;T item;};const int MaxSize=100;template <class T>class SpareMatrix{private:element<T> data[MaxSize];int mu,nu,tu;//定义行数,列数,非零元素个数public:SpareMatrix(element<T> Data[],int Mu,int Nu,int Tu);SpareMatrix(){}~SpareMatrix(){}void Print();void OrignalMatrix();friend void Transfer(SpareMatrix &A,SpareMatrix &B);};template <class T>SpareMatrix<T>::SpareMatrix( element<T> Data[],int Mu,int Nu,int Tu) {for(int i=0;i<Tu;i++){data[i].row=Data[i].row;data[i].col=Data[i].col;data[i].item=Data[i].item;}mu=Mu;nu=Nu;tu=Tu;}template <class T>void SpareMatrix<T>::Print(){cout<<"********打印稀疏矩阵的存储情况*********"<<endl;for(int i=0;i<tu;i++){cout<<data[i].row<<" ";cout<<data[i].col<<" ";cout<<data[i].item<<" ";cout<<endl;}}template <class T>void SpareMatrix<T>::OrignalMatrix(){cout<<"***********原始矩阵如下***********"<<endl;int M[10][10]={0};for(int i=0;i<tu;i++)M[data[i].row][data[i].col]=data[i].item;for(i=0;i<mu;i++){for(int j=0;j<nu;j++)cout<<M[i][j]<<" ";cout<<endl;}}template <class T>void Transfer(SpareMatrix<T> &A,SpareMatrix<T> &B){B.mu=A.nu;B.nu=A.mu;B.tu=A.tu;if(A.tu>0){for(int i=0;i<A.tu;i++){B.data[i].row=A.data[i].col;B.data[i].col=A.data[i].row;B.data[i].item=A.data[i].item;}}}void main(){cout<<"************关于稀疏矩阵的操作************"<<endl;int M[10][10];int NonZero=0;int Row,Column;cout<<"输入稀疏矩阵的行数与列数:";cin>>Row>>Column;cout<<"请初始化稀疏矩阵("<<Row<<"*"<<Column<<"):"<<endl;int i,j;for( i=0;i<Row;i++)for(j=0;j<Column;j++){cin>>M[i][j];}for(i=0;i<Row;i++)for(j=0;j<Column;j++){if(M[i][j]!=0)NonZero++;}element<int> E1[MaxSize];int loc=0;for(i=0;i<Row;i++)for(j=0;j<Column;j++){if(M[i][j]!=0){E1[loc].row=i;E1[loc].col=j;E1[loc].item=M[i][j];loc++;}}SpareMatrix<int> S1(E1,Row,Column,NonZero);S1.Print ();S1.OrignalMatrix();SpareMatrix<int> S2;cout<<"**********稀疏矩阵的转置*************"<<endl;Transfer(S1,S2);S2.Print();S2.OrignalMatrix();}。

稀疏矩阵实验报告

稀疏矩阵实验报告

一、实验目的1. 理解稀疏矩阵的概念和特点。

2. 掌握稀疏矩阵的三元组表示方法。

3. 熟悉稀疏矩阵的基本运算,如转置、加法、减法等。

4. 提高编程能力和问题解决能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 稀疏矩阵的三元组表示- 设计稀疏矩阵的三元组存储结构。

- 编写函数实现稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置。

- 实现稀疏矩阵的加法、减法。

- 实现稀疏矩阵的乘法。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

四、实验步骤1. 稀疏矩阵的三元组表示- 定义稀疏矩阵的三元组存储结构,包括行号、列号和元素值。

- 编写函数实现稀疏矩阵的三元组表示,包括读取稀疏矩阵的三元组数据、构建稀疏矩阵的三元组表示等。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

- 分析实验结果,得出稀疏矩阵运算的优缺点。

五、实验结果1. 稀疏矩阵的三元组表示- 读取稀疏矩阵的三元组数据,构建稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高,尤其在稀疏程度较高的矩阵上。

- 稀疏矩阵运算的缺点是存储空间较大,且运算过程中需要频繁进行数据交换。

数据结构实验报告实验五稀疏矩阵运算器

数据结构实验报告实验五稀疏矩阵运算器

一、引言稀疏矩阵是一个具有大量零元素的矩阵,对于大规模的矩阵来说,如果没有充分利用矩阵的稀疏性质,将会带来很大的存储空间和计算时间上的浪费。

为了解决这个问题,我们需要通过设计一个稀疏矩阵运算器来对稀疏矩阵进行各种运算,以提高计算效率。

二、实验目标本实验的主要目标是设计一个稀疏矩阵运算器,通过实现对稀疏矩阵的加法、乘法和转置等操作,实现对稀疏矩阵的高效运算。

三、设计思路和方法1. 矩阵的表示方式在设计稀疏矩阵运算器时,我们需要选择合适的数据结构来表示稀疏矩阵。

由于稀疏矩阵中大部分元素为零,我们可以采用压缩存储的方法来表示稀疏矩阵。

一种常用的压缩存储方法是使用三元组表示法,即将矩阵的非零元素的值、所在的行号和列号分别存储在一个三元组中。

2. 加法运算稀疏矩阵的加法运算是指将两个稀疏矩阵进行对应位置的相加操作。

在进行稀疏矩阵的加法运算时,首先需要判断两个矩阵的维度是否相同,然后通过遍历两个矩阵的非零元素,将相同位置的元素进行相加得到结果。

3. 乘法运算稀疏矩阵的乘法运算是指将两个稀疏矩阵进行矩阵乘法操作。

在进行稀疏矩阵的乘法运算时,首先需要判断第一个矩阵的列数是否等于第二个矩阵的行数,然后通过遍历两个矩阵的非零元素,按照行和列的顺序对应相乘,再将相乘的结果加到结果矩阵中。

4. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。

在进行稀疏矩阵的转置运算时,只需要将矩阵的非零元素的行号和列号对换即可。

五、实验结果与分析我们在实现稀疏矩阵运算器后,对其进行了测试。

通过测试,我们发现稀疏矩阵运算器能够正确地进行稀疏矩阵的加法、乘法和。

稀疏矩阵课程设计实验报告

稀疏矩阵课程设计实验报告

数据结构课程设计学院:信息科学与工程学院专业:计算机科学与技术班级:计算机1108学号:学生姓名:指导教师:2013 年 3 月 10 日稀疏矩阵一、实验内容基本要求:1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加、想减、相乘的运算。

2.稀疏矩阵的输入形式采用三元组表表示,而运算结果则以通常的阵列形式输出选作内容:1.按书中的描述方法,以十字链表表示稀疏矩阵2.增添矩阵求逆的运算,包括不可求逆的情况。

在求逆之前,先将稀疏矩阵的内容表示改为十字链表…二、数据结构设计三元组结构体定义如下:#include <stdio.h>#include <stdlib.h>#define MAX 100typedef struct{int i,j;int e;}Triple;struct juzhen{Triple data[MAX+1];int first[MAX+1];int mv,nv,tv;};十字链表结构定义如下#include<stdio.h>#include<stdlib.h>#include<conio.h>typedef int ElemType;typedef struct CLNode{int row ;int col;ElemType fenzi;ElemType fenmu;CLNode * right;CLNode * down;}CLNode;typedef struct{CLNode ** rhead;CLNode ** chead;int ru;int lu;int tu;}CrossList;三、算法设计1.三元组表构建稀疏矩阵的定义如下:ADT Matrix{数据对象:D={a ij|i=1,2,…,m; j=1,2,…,n;a ij∈ElemSet, m和n分别为矩阵的行数和列数}数据关系:R={Row,Col }Row={﹤a i,j, a i,j+1﹥| 1≤i≤m, 1≤j≤n-1}Col = {﹤a i,j, a i+1,j﹥| 1≤i≤m-1, 1≤j≤n}基本操作:ChuangJian (XiShu &M)操作结果:创建稀疏矩阵矩阵TMShuChu(XiShu Q)操作结果:通常形式输出稀疏矩阵AddMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的加法运算:void JianMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的减法运算void ChengMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的乘法运算}ADT Matrix;2 十字链表创建稀疏矩阵的定义如下:ADT SparseMatrix{数据对象 D={a ij|i=1,2,3……m,j=1,2,3……n;a ij属于ElemSet,m和n分别是稀疏矩阵的行数和列数}数据关系 R={ Row, Col }Row={<a ij,a ij+1>|1<=i<=m,1<=j<=n-1}Col={<a ij,a i+1j>|1<=i<=m-1,1<=j<=n}基本操作:void Input( CrossList &D )操作结果:十字链表创建稀疏矩阵int Determinant( const CrossList &D ,int row , int line )操作结果:求稀疏矩阵行列式的值void Reduction( int &fenzi, int &fenmu )操作结果:分子分母约分CrossList *InverseMatrix( const CrossList &D )操作结果:求稀疏矩阵的逆矩阵void Output( const CrossList *E )操作结果:十字邻接矩阵的输出}ADT SparseMatrix3.1 功能模块图本功能分为四个模块3.2 算法思路3.2.1实现方法列出系统中的所有函数并说明函数的功能void main() //三元组表法和十字链表的主函数int ChuangJian(XiShu *M) //三元组表法创建稀疏矩阵void ShuChu(XiShu Q) //三元组表法输出稀疏矩阵void AddMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相加功能void JianMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相减功能void ChengMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相乘功能int Determinant(CrossList &D ,int row ,int line )//行列式求值void Reduction( int &fenzi, int &fenmu ) //分子分母约分void Input( CrossList &D ) //十字链表输入函数CrossList *InverseMatrix(CrossList &D)//求稀疏矩阵的逆矩阵void Output( const CrossList *E ) //十字链表输出函数3.2.2 设计思想稀疏矩阵加法运算思路:首先判断两个矩阵行数列数是否相等,比较两个矩阵中不为0的元素的行数i 及列数j,将i与j都相等的前后两个元素值e相加,保持i,j不变储存在新的三元组中,不等的则分别储存在此新三元组中稀疏矩阵减法运算思路:将后一个矩阵的每一个非零元都乘以-1,再调用加法运算的函数稀疏矩阵乘法运算思路:逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加稀疏矩阵求逆运算的思路:矩阵的逆等于矩阵的伴随矩阵除以矩阵行列式的值(1)定义全局变量#define MAX 100#define TRUE 1#define FAULT 0typedef int ElemType;(2)主函数模块说明主函数主要结构void main( ){ 初始化;Switch(){Case :接受命令;选择处理命令}不满足退出}void main( ){初始化;接受命令;选择处理命令}(3)其他模块说明(用文字描述,不要代码)int CreateSMatrix(TSMatrix *M){初始化;输入行数、列数、非零元个数for(){for()按行为主序输入每一个非零元赋值}返回结果}void PrintSMatrix(TSMatrix Q){两层for循环输出每一个非零元}void AddRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){判断行数、列数是否对应相等,若均相等则相加并赋值否则依次判断行数、列数的大小并再次判断将值放在另一个数组里}Void JianRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){两层for循环将第二个矩阵的每一个非零元变为他的负数再调用相加函数}void MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){初始化判断第一个矩阵的行数时候等于第二个矩阵的列数然后逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加}四、测试数据及程序运行情况三元组表实现加法运算三元组表实现乘法运算十字链表实现求逆运算五、实验过程中出现的问题及解决方案1)问题:运行过程中发现加法减法能正常运行,而乘法却在计算时出现问题。

实验七 稀疏矩阵

实验七 稀疏矩阵

实验报告七稀疏矩阵操作实验
班级:姓名:学号:专业:
一、实验目的:
1、了解多维数组的存储方式和存取特点
2、熟悉稀疏矩阵的存储方式
3、用三元组法实现稀疏矩阵的相、减、转置算法。

二、实验内容:(请采用模板类及模板函数实现)
1、稀疏矩阵三元组存储表示及基本操作算法实现
[实现提示] (同时可参见教材p130-p133页算法)函数、类名称等可自定义,部分变量请加上学号后3位。

也可自行对类中所定义的操作进行扩展。

所加载的库函数或常量定义及类的定义:
(1)稀疏矩阵的三元组顺序存储结构类定义:
自定义如下:
(2)构造稀疏矩阵算法;(输入参数自定义)
(3)打印稀疏矩阵算法;
(4)两稀疏矩阵相加,获得一新的矩阵的算法;(自行设计)
初始条件:稀疏矩阵M与N的行数和列数对应相等
(5)两稀疏矩阵相减,获得一新的矩阵的算法;(自行设计)
初始条件:稀疏矩阵M与N的行数和列数对应相等
(6)求稀疏矩阵M的转置矩阵T算法;
初始条件:M存在。

测试结果如下:
选做题:
1、实现多维数组的顺序存储表示和操作算法。

(操作函数自定义,可参见课件)
2、参考p134页,实现稀疏矩阵十字链表存储类定义和创建操作算法。

三、实验心得(含上机中所遇问题的解决办法,所使用到的编程技巧、创新点及编程的
心得)。

稀疏矩阵实验报告需求分析,1200字

稀疏矩阵实验报告需求分析,1200字

稀疏矩阵实验报告需求分析需求分析报告:稀疏矩阵实验报告引言:稀疏矩阵是在矩阵中非零元素的个数远远小于零元素的个数的情况下,通过一种特殊的数据结构来存储和表示矩阵。

稀疏矩阵实验报告是对稀疏矩阵的存储和运算的实验过程的记录和总结,对于研究稀疏矩阵的性质和算法有着重要的意义。

本篇报告将对稀疏矩阵实验报告的需求进行详细分析,包括实验目的、实验方法、实验过程、实验结果和实验结论等方面。

一、实验目的(约200字):本实验旨在通过对稀疏矩阵的存储和运算的实验,掌握稀疏矩阵的特点、存储方式和运算方法,进一步了解并熟悉稀疏矩阵的相关算法和应用场景。

具体目的包括:掌握稀疏矩阵的存储结构和实现方法;了解常见的稀疏矩阵运算方法;分析稀疏矩阵算法在实际应用中的效果。

二、实验方法(约200字):本实验采用稀疏矩阵的压缩存储方法,包括三元组顺序表和十字链表两种方式。

在实验过程中,首先需要编写程序实现稀疏矩阵的创建和初始化,并通过输入或读取文件的方式导入测试数据。

其次,需要实现稀疏矩阵的基本运算,包括矩阵的加法、减法和乘法等。

最后,根据实际需求选择合适的测试数据,并对实验结果进行统计和分析。

三、实验过程(约300字):实验过程分为以下几个步骤:1. 稀疏矩阵的创建与初始化:根据实验需求,选择适当的稀疏矩阵存储方式,如三元组顺序表或十字链表,并编写相关程序进行创建与初始化。

2. 导入测试数据:通过输入或读取文件的方式,导入测试数据,包括稀疏矩阵的维度和非零元素的位置和值等信息。

3. 稀疏矩阵的基本运算:实现稀疏矩阵的加法、减法和乘法等基本运算,验证程序的正确性。

4. 测试与分析:选择合适的测试数据进行实验,记录实验结果,并对结果进行统计和分析,包括稀疏矩阵存储方式的对比和算法的效率比较等。

5. 编写实验报告:总结实验过程和结果,撰写实验报告,包括实验目的、实验方法、实验过程、实验结果和实验结论等内容。

四、实验结果与分析(约300字):通过本次实验,我们成功实现了稀疏矩阵的存储和运算。

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

稀疏矩阵基本操作班级:计算机科学与技术(2)班小组成员:日期:2012年4月17日1.需求分析【实验目的】熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现,及利用高级程序设计语言中已存在的数据类型来说明新的结构,用已经实现的操作来组合新的操作,具体实现细节则依赖于所用的语言的功能。

通过本次实习还可以帮助读者复习高级语言的使用方法。

掌握数组的特点及基本操作,如存储、输出、乘积、转置等,,以便在实际问题背景下灵活应用。

【基本要求】1.用C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。

2.概要设计栈的抽象数据类型ADT Matrix {数据对象:D={aij| i=1,2,…,m;j=1,2,…,n;ai∈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}基本操作:CreatSMatrix(&M)操作结果:构造一个稀疏矩阵。

Destroy SMatix (&M)初始条件:稀疏矩阵M已存在。

操作结果:销毁稀疏矩阵M。

PrintSMtrix(&M)初始条件:稀疏矩阵已存在。

操作结果:输出稀疏矩阵M。

CompSMtrix(M,&T)初始条件:稀疏矩阵M已存在。

操作结果:由稀疏矩阵M复制得到T。

AddSMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数相等。

操作结果:求稀疏矩阵的和Q=M+N。

SubtMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数对应相等。

操作结果:求稀疏矩阵的差Q=M-N。

MultSMtrix(M,N,&Q)初始条件:稀疏矩阵的M的列数等于N的的行数。

操作结果:求稀疏矩阵的差Q=M x N。

TransposeSMatrix(M,&T) 初始条件:栈S已存在且非空。

操作结果:删除S的栈顶元素,并用e返回其值。

}ADT SparseSMatrix3.详细设计//------------稀疏矩阵的三元组顺序表存储表示------------------- #define MAXSIZE 12500typedef struct{int i,j; //该飞了那个元素的行下标和列下标ElemType e;}Triple;Typedef struct{Triple data[MAXSIZE+1];//非零元三元组表,data[0]未用int mu,nu,tu; //矩阵的行数、列数和非零元素的个数}TSMatrix;4.测试结果:M= 0 0 4 0 03 7 0 0 00 5 0 8 04 0 0 2 10N= 0 0 06 0 70 0 90 4 00 0 85.附录:源程序:Matrix.h //函数申明#include<stdio.h>#define MAXSIZE 100 //非零元个数的最大值typedef struct triple{int i,j; // 行下标,列下标int e; // 非零元素值}triple;typedef struct tsmatrix{triple data[MAXSIZE+1]; //非零元三元组表,data[0]未用int mu,nu,tu; //矩阵的行数、列数和非零元个数}rlsmatrix;createsmatrix(rlsmatrix *M); //创建稀疏矩阵Mvoid transposesmatrix(rlsmatrix M,rlsmatrix *T); //求矩阵的快速转置multsmatrix(rlsmatrix M,rlsmatrix N,rlsmatrix *T);//求矩阵乘积Q=M x Nvoid printmatrix(rlsmatrix M); //输出Matrix.c //函数定义createsmatrix(rlsmatrix *M) //创建稀疏矩阵M{int e,i,m,n;M->data[0].i=0; // 为以下比较顺序做准备printf("请输入矩阵的行数,列数,和非零元素的个数\n");printf("行数:");scanf("%d",&M->mu);printf("列数:");scanf("%d",&M->nu);printf("非零元素个数:");scanf("%d",&M->tu);for(i=1;i<=M->tu;i++){printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值\n",i,M->mu,M->nu);printf("行数:");scanf("%d",&m);printf("列数:");scanf("%d",&n);printf("元素值:");scanf("%d",&e);if(m<1||m>M->mu||n<1||n>M->nu) //行或列超出范围{printf("行或列超出范围,现退出程序,请核对后在输入");getch();exit();}if(m<M->data[i-1].i||m==M->data[i-1].i&&n<=M->data[i-1].j) //行或列的顺序有错{printf("行或列的顺序有错");getch();exit();}M->data[i].i=m;M->data[i].j=n;M->data[i].e=e;}}void transposesmatrix(rlsmatrix M,rlsmatrix *T) //求矩阵的快速转置{ //cpos存放每列的第一个非零元素的地址,temp中间变量int i,m,*cpos,*temp,k=0;T->mu=M.nu;T->nu=M.mu;T->tu=M.tu;cpos=(int *)malloc(M.mu*sizeof(int));if(cpos==NULL)exit();temp=(int *)malloc(M.mu*sizeof(int));if(temp==NULL)exit();//对cpos对初始化,初值为0*(cpos+1)=0;for(i=1;i<=M.nu;i++){for(m=1;m<=M.tu;m++){if(M.data[m].j==i)k++;}temp[i]=k;if(i==1&&k!=0)*(cpos+i)=1;//为cpos赋值if(i>1)*(cpos+i)=*(temp+i-1)+1;}free(temp);for(i=1;i<=M.tu;i++) //进行转置{T->data[*(cpos+M.data[i].j)].i=M.data[i].j;T->data[*(cpos+M.data[i].j)].j=M.data[i].i;T->data[*(cpos+M.data[i].j)].e=M.data[i].e;(*(cpos+M.data[i].j))++;}free(cpos);}multsmatrix(rlsmatrix M,rlsmatrix N,rlsmatrix *T){int i,j,Qn=0;int *Qe;if(M.nu!=N.mu){printf("两矩阵无法相乘");getch();exit();}T->mu=M.mu;T->nu=N.nu;Qe=(int *)malloc(M.mu*N.nu*sizeof(int)); //Qe为矩阵Q的临时数组for(i=1;i<=M.mu*N.nu;i++)*(Qe+i)=0; //矩阵Q的第i行j列的元素值存于*(Qe+(M.data[i].i-1)*N.nu+N.data[j].j)中,初值为0for(i=1;i<=M.tu;i++) //结果累加到Qefor(j=1;j<=N.tu;j++)if(M.data[i].j==N.data[j].i)*(Qe+(M.data[i].i-1)*N.nu+N.data[j].j)+=M.data[i].e*N.data[j].e;for(i=1;i<=M.mu;i++) //Qe矩阵中,因为M的每一行和N的每一列相乘都是T的一个元素,不管它是零或非零for(j=1;j<=N.nu;j++) //当M的第一行和N的第一列相乘则得T的第一个元素;当M的第一行和N的第二列相乘则得T的第二个元素if(*(Qe+(i-1)*N.nu+j)!=0) //当M的第i行和N的第j列相乘则得T的第p个元素;根据归纳法得p=(i-1)*N的列数+j{Qn++;//非零元个数加一T->data[Qn].e=*(Qe+(i-1)*N.nu+j);T->data[Qn].i=i;T->data[Qn].j=j;}free(Qe);T->tu=Qn;return 1;}void printmatrix(rlsmatrix M)//输出{int i,m=1,n,k;printf("矩阵的简化模式是:\n");for(i=1;i<=M.tu;i++)printf("%d,%d,%d\n",M.data[i].i,M.data[i].j,M.data[i].e);printf("矩阵的行数是:%d\n",M.mu);printf("矩阵的列数是:%d\n",M.nu);printf("矩阵中非零元素个数是:%d\n",M.tu);printf("矩阵的完整模式的:\n");for(n=1;n<=M.mu;n++){for(k=1;k<=M.nu;k++){if(M.data[m].i==n&&M.data[m].j==k){printf("%3d",M.data[m].e);m++;}elseprintf(" 0");}printf(" \n");}return 1;}main.c //主函数#include<stdio.h>#include "Matrix.h"#include "Matrix.c"void main(){rlsmatrix M,N,T,K;printf("请为矩阵M赋值!\n");createsmatrix(&M);printmatrix(M);printf("请为矩阵N赋值!\n");createsmatrix(&N);printmatrix(N);getch();printf("矩阵M*N得矩阵T!\n");multsmatrix(M,N,&T);printmatrix(T);getch();printf("对矩阵T进行转置!");getch();transposesmatrix(T,&K);printf("转置后的矩阵是\n");printmatrix(K);getch();}5.小结:任然有部分问题尚未解决,例如在输出矩阵乘积是,弹出如下对话框:但忽略却不影响运算结果。

相关文档
最新文档