数据结构课程设计之稀疏矩阵实现与应用1
数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析
![数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析](https://img.taocdn.com/s3/m/a17a0266182e453610661ed9ad51f01dc28157f0.png)
数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析稀疏矩阵是指矩阵中大部分元素为零的特殊矩阵。
在实际应用中,稀疏矩阵经常出现,如图像处理、网络分析和科学计算等领域。
对于稀疏矩阵的存储和操作是数据结构中的重要内容。
本文将介绍稀疏矩阵的存储方式和相关操作的分析。
一、稀疏矩阵存储方式稀疏矩阵的存储方式有多种,其中三元组顺序表和二维数组是比较常用的方法。
1. 三元组顺序表三元组顺序表是一种基于行优先存储的方式,可以将稀疏矩阵以非零元素的形式存储起来。
主要包括行号、列号和元素值三个信息。
以一个4x5的稀疏矩阵为例,其中有三个非零元素分别为A[1][2]=3, A[2][3]=4, A[3][4]=5。
可以使用三元组顺序表来存储:```行号列号元素值1 2 32 3 43 4 5```三元组顺序表的优点是可以节省存储空间,同时也方便进行矩阵的操作。
但是在进行元素的查找和修改时,效率较低。
2. 二维数组二维数组是一种常见的矩阵表示方法,可以直接使用二维数组来表示稀疏矩阵。
其中非零元素的位置用实际的值表示,其余位置用零值表示。
以同样的4x5的稀疏矩阵为例,使用二维数组存储如下:```0 0 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5```二维数组的优点是简单直观,并且可以快速进行元素的查找和修改。
但当稀疏矩阵的规模较大时,会造成较高的存储资源浪费。
二、稀疏矩阵的操作分析对于稀疏矩阵的操作,主要包括矩阵的转置、相加、相乘等。
1. 转置操作稀疏矩阵的转置是指将原始矩阵的行与列对调。
对于三元组顺序表来说,转置操作主要涉及到行号和列号的交换。
而对于二维数组来说,可以直接在取值的时候将行号和列号对调即可。
2. 相加操作稀疏矩阵的相加操作是指将两个矩阵对应位置的元素相加。
对于三元组顺序表来说,可以通过遍历两个矩阵的非零元素,并将其对应位置的元素相加。
而对于二维数组来说,可以直接将对应位置的元素相加即可。
3. 相乘操作稀疏矩阵的相乘操作是指将两个矩阵相乘得到一个新的矩阵。
数据结构实验报告稀疏矩阵运算
![数据结构实验报告稀疏矩阵运算](https://img.taocdn.com/s3/m/878d939081eb6294dd88d0d233d4b14e85243eb2.png)
数据结构实验报告稀疏矩阵运算实验目的:1.学习并理解稀疏矩阵的概念、特点以及存储方式。
2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。
3.实现稀疏矩阵加法、乘法的算法,并进行性能测试和分析。
实验原理:稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。
在实际问题中,有许多矩阵具有稀疏性,例如文本矩阵、图像矩阵等。
由于存储稀疏矩阵时,对于大量的零元素进行存储是一种浪费空间的行为,因此需要采用一种特殊的存储方式。
常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。
其中,三元组顺序表是最简单直观的一种方式,它是将非零元素按行优先的顺序存储起来,每个元素由三个参数组成:行号、列号和元素值。
此外,还需要记录稀疏矩阵的行数、列数和非零元素个数。
稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历,对于相同位置的元素进行相加,得到结果矩阵。
稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算,即行乘以列的和。
实验步骤:1.实现稀疏矩阵的三元组顺序表存储方式,并完成稀疏矩阵的初始化、转置、打印等基本操作。
2.实现稀疏矩阵的加法运算,并进行性能测试和分析。
3.实现稀疏矩阵的乘法运算,并进行性能测试和分析。
4.编写实验报告。
实验结果:经过实验测试,稀疏矩阵的加法和乘法算法都能正确运行,并且在处理稀疏矩阵时能够有效节省存储空间。
性能测试结果表明,稀疏矩阵加法、乘法的运行时间与非零元素个数有关,当非零元素个数较少时,运算速度较快;当非零元素个数较多时,运算速度较慢。
实验分析:稀疏矩阵的运算相对于普通矩阵的运算有明显的优势,可以节省存储空间和运算时间。
在实际应用中,稀疏矩阵的存储方式和运算算法都可以进行优化。
例如,可以采用行逻辑链接表的方式存储稀疏矩阵,进一步减少存储空间的占用;可以采用并行计算的策略加快稀疏矩阵的运算速度。
总结:通过本次实验,我深入学习了稀疏矩阵的概念、特点和存储方式,掌握了稀疏矩阵加法、乘法的基本思想和算法,并通过实验实现了稀疏矩阵的加法、乘法运算。
稀疏矩阵(算法与数据结构课程设计)
![稀疏矩阵(算法与数据结构课程设计)](https://img.taocdn.com/s3/m/35722b49cf84b9d528ea7a68.png)
稀疏矩阵一、问题描述假若在n m ⨯阶中,有t 个元素不为零,令nm t ⨯=δ称为矩阵的稀疏因子。
通常认为≤δ0.05时称为稀疏矩阵。
稀疏矩阵的研究大大的减少了数据在计算机中存储所需的空间,然而,它们的运算却与普通矩阵有所差异。
通过本次实验实现稀疏矩阵的转置、加法和乘法等多种运算。
二、基本要求1、稀疏矩阵采用三元组表示,建立稀疏矩阵,并能按矩阵和三元组方式输出;2、编写算法,完成稀疏矩阵的转置操作;3、编写算法,完成对两个具有相同行列数的稀疏矩阵进行求和操作;4、编写算法,对前一矩阵行数与后一矩阵列数相等的两个矩阵,完成两个稀疏矩阵的相乘操作。
三、测试数据1、转置操作的测试数据:⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200013000010020100 2、相加操作的测试数据: ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200013000010020100 ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛00200010000210030300 3、相乘操作的测试数据: ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛0000000300400021 ⎪⎪⎪⎪⎪⎭⎫ ⎝⎛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不变储存在新的三元组中,不等的则分别储存在此新三元组中。
稀疏矩阵存储和操作稀疏矩阵的数据结构与算法
![稀疏矩阵存储和操作稀疏矩阵的数据结构与算法](https://img.taocdn.com/s3/m/d3988af6f021dd36a32d7375a417866fb94ac054.png)
稀疏矩阵存储和操作稀疏矩阵的数据结构与算法稀疏矩阵是指具有大量零元素和少量非零元素的矩阵。
在实际场景中,由于矩阵中大部分元素为零,传统的矩阵存储方式会造成大量的存储空间的浪费以及数据操作的低效性。
因此,为了节省存储空间和提高数据操作的效率,稀疏矩阵的存储和操作需要借助于特定的数据结构和算法。
一、稀疏矩阵存储的数据结构1.1. 压缩存储方法压缩存储方法是一种常用的稀疏矩阵存储方法。
常见的压缩存储方法有三种:行压缩法(CSR)、列压缩法(CSC)和十字链表法。
1.1.1. 行压缩法(CSR)行压缩法是通过两个数组来存储稀疏矩阵的非零元素。
第一个数组存储非零元素的值,第二个数组存储非零元素在矩阵中的位置信息。
1.1.2. 列压缩法(CSC)列压缩法与行压缩法相似,只是存储方式不同。
列压缩法是通过两个数组来存储稀疏矩阵的非零元素。
第一个数组存储非零元素的值,第二个数组存储非零元素在矩阵中的位置信息。
1.1.3. 十字链表法十字链表法是一种更加灵活的稀疏矩阵存储方法。
通过使用链表的方式,将非零元素存储在链表中,并且每个非零元素还具有行和列的指针,方便进行数据操作。
1.2. 坐标存储法坐标存储法是一种简单直观的稀疏矩阵存储方法。
每个非零元素包括行列坐标和元素值,通过三元组的方式进行存储。
二、稀疏矩阵的操作算法2.1. 矩阵转置矩阵转置是指将原矩阵的行变为列,列变为行的操作。
对于稀疏矩阵,常用的转置算法为快速转置算法。
该算法通过统计每列非零元素的个数,并根据列的非零元素个数确定每个非零元素转置后的位置。
2.2. 矩阵相加矩阵相加是指将两个矩阵对应位置上的元素相加得到一个新的矩阵。
对于稀疏矩阵的相加,可以遍历两个矩阵的非零元素,对相同位置上的元素进行相加。
2.3. 矩阵相乘矩阵相乘是指将两个矩阵相乘得到一个新的矩阵。
对于稀疏矩阵的相乘,常用的算法为稀疏矩阵乘法算法。
该算法通过遍历两个矩阵的非零元素,按照矩阵乘法的规则计算得到新矩阵的非零元素。
数据结构课程设计稀疏矩阵
![数据结构课程设计稀疏矩阵](https://img.taocdn.com/s3/m/45905f150b4e767f5acfcee4.png)
稀疏矩阵应用摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。
在程序设计中,考虑到方法的难易程度,采用了先用三元组实现稀疏矩阵的输入,输出,及其转置,相加,相乘操作的方法,再在十字链表下实现。
程序通过调试运行,结果与预期一样,初步实现了设计目标。
关键词程序设计;稀疏矩阵;三元组;十字链表1 引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。
稀疏矩阵采用三元组和十字链表表示,并在两种不同的存储结构下,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;求出A的转置矩阵D,输出D;求两个稀疏矩阵A和B的相乘矩阵E,并输出E。
1.2课程设计性质数据结构课程设计是重要地实践性教学环节。
在进行了程序设计语言课和《数据结构》课程教学的基础上,设计实现相关的数据结构经典问题,有助于加深对数据结构课程的认识。
本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现,包括在三元组和十字链表下存储稀疏矩阵,并对输入的稀疏矩阵进行转置,相加,相乘等操作,最后把运算结果输出。
此课程设计要求对数组存储结构和链表存储结构非常熟悉,并能熟练使用它们。
1.3课程设计目的其目的是让我们在学习完C、数据结构等课程基础上,掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置,相加,相乘等基本操作,并用不同的方法输出结果,进一步掌握设计、实现较大系统的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。
2需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化,包括在三元组结构下和十字链表结构下。
首先要定义两种不同的结构体类型,在创建稀疏矩阵时,需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵,在输入出现错误时,能够对错误进行判别处理,初始化稀疏矩阵都为空值,特别注意在十字链表下,对变量进行动态的地址分配。
稀疏矩阵的相关操作
![稀疏矩阵的相关操作](https://img.taocdn.com/s3/m/a9a817cdd1d233d4b14e852458fb770bf78a3bd3.png)
稀疏矩阵的相关操作稀疏矩阵是指在一个矩阵中,大部分元素为0的矩阵。
由于大部分元素为0,而非零元素相对较少,稀疏矩阵的存储和处理具有一定的特殊性。
在实际应用中,经常需要对稀疏矩阵进行各种操作,如创建、存储、加法操作等。
本文将从这些方面详细介绍稀疏矩阵的相关操作。
首先,创建稀疏矩阵需要考虑两个关键因素:矩阵的大小和矩阵的稀疏性。
对于稀疏矩阵的大小,一般可以使用行数和列数来描述。
而对于稀疏矩阵的稀疏性,可以使用一个矩阵的非零元素个数与总元素个数的比值来衡量,一般使用稀疏度来表示,即非零元素个数与总元素个数的比值。
创建稀疏矩阵的方法有多种,下面介绍两种常见的方法。
1.压缩矩阵存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个矩阵中。
其中,矩阵的每一行存储一个非零元素的值、行和列坐标。
这种方法虽然节约了存储空间,但是在进行矩阵操作时,需要通过遍历矩阵找到对应的非零元素,因此操作效率较低。
2.链表存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个链表中。
链表的每个节点包含一个非零元素的值、行和列坐标,以及下一个非零元素的指针。
这种方法在插入和删除操作时比较方便,并且节约了存储空间。
但是,链表存储法在进行矩阵操作时,也需要通过遍历链表找到对应的非零元素,因此操作效率较低。
除了创建稀疏矩阵,还需要进行其他各种操作,如稀疏矩阵的加法、乘法、转置等。
稀疏矩阵的乘法操作较为复杂。
对于两个稀疏矩阵相乘,需要根据矩阵乘法的定义,将一个矩阵的行与另一个矩阵的列进行乘法运算,然后将结果相加得到最终的乘积矩阵。
由于稀疏矩阵的特殊性,可以采用稀疏矩阵乘法算法进行计算,提高乘法操作的效率。
1.三元组转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在三个数组中,分别是非零元素数组、行坐标数组和列坐标数组。
将这三个数组的元素进行转置,并重新组合成转置后的稀疏矩阵。
2.链表转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在链表中。
数据结构——稀疏矩阵运算器
![数据结构——稀疏矩阵运算器](https://img.taocdn.com/s3/m/38f50656a88271fe910ef12d2af90242a995ab6f.png)
数据结构——稀疏矩阵运算器目录1. 简介1.1 概述1.2 稀疏矩阵的定义2. 数据结构设计2.1 稀疏矩阵的存储方式2.2 稀疏矩阵的数据结构设计3. 基本操作3.1 创建稀疏矩阵3.2 初始化稀疏矩阵的元素3.3 稀疏矩阵的加法3.4 稀疏矩阵的减法3.5 稀疏矩阵的乘法4. 高级操作4.1 稀疏矩阵的转置4.2 稀疏矩阵的快速乘法5. 示例应用5.1 矩阵乘法示例5.2 矩阵转置示例6. 总结与展望1. 简介1.1 概述稀疏矩阵是一种具有大量零元素的矩阵,对于大规模稀疏矩阵的运算,传统的矩阵运算方法效率较低。
本文档介绍了一种稀疏矩阵运算器的设计和实现。
1.2 稀疏矩阵的定义稀疏矩阵是指矩阵中大部分元素为零的矩阵。
相比于密集矩阵,稀疏矩阵的存储和运算可以进行有效的优化,提高运算效率。
2. 数据结构设计2.1 稀疏矩阵的存储方式稀疏矩阵可以使用多种方式进行存储,常见的方法有三元组表示法和十字链表表示法。
本文档使用三元组表示法进行存储。
2.2 稀疏矩阵的数据结构设计稀疏矩阵的数据结构设计包括矩阵的行数、列数和非零元素的个数等基本信息,以及按照行优先的方式存储稀疏矩阵的非零元素和对应的行列索引。
3. 基本操作3.1 创建稀疏矩阵创建稀疏矩阵的操作包括输入矩阵的行数和列数,以及非零元素的个数,以便为矩阵分配内存空间。
3.2 初始化稀疏矩阵的元素初始化稀疏矩阵的操作包括输入矩阵的非零元素及其对应的行列索引。
3.3 稀疏矩阵的加法实现稀疏矩阵的加法运算,包括对两个稀疏矩阵进行相应的遍历和运算操作。
3.4 稀疏矩阵的减法实现稀疏矩阵的减法运算,包括对两个稀疏矩阵进行相应的遍历和运算操作。
3.5 稀疏矩阵的乘法实现稀疏矩阵的乘法运算,包括对两个稀疏矩阵进行相应的遍历和运算操作。
4. 高级操作4.1 稀疏矩阵的转置实现稀疏矩阵的转置操作,包括对稀疏矩阵的行列索引进行互换。
4.2 稀疏矩阵的快速乘法通过对矩阵进行合并和切分等操作,实现稀疏矩阵的快速乘法运算,提高运算效率。
《数据结构 课程设计》稀疏矩阵实验报告
![《数据结构 课程设计》稀疏矩阵实验报告](https://img.taocdn.com/s3/m/f69d502b6bd97f192279e9c1.png)
(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
数据结构课程设计 报告 (十字链表实现稀疏矩阵的加法)
![数据结构课程设计 报告 (十字链表实现稀疏矩阵的加法)](https://img.taocdn.com/s3/m/6f27de72a417866fb84a8e17.png)
一、问题描述十字链表实现稀疏矩阵的加法1、功能要求:根据用户输入的矩阵,实现稀疏矩阵的求和运算,并输出结果。
2、输入要求:矩阵的数据在程序运行的时候由用户提供,先由用户输入稀疏矩阵的行数、列数和非零元个数。
再根据非零元个数,输入这些非零元,还需要用户为这些非零元输入行、列和非零元的值。
这样,一个稀疏矩阵就输入完成。
若输入4 3 2则表示这个稀疏矩阵有4行3列2个非零元然后用户需要为这两个非零元输入行、列、非零元的值如:1 2 24 1 1表示第一个非零元行为1,列为2,,值为2;第二个非零元行为4,列为1,值为1。
此过程输入的稀疏矩阵为:0 2 00 0 00 0 01 0 03、输出要求:输出按矩阵输出,按行列依次输出,非零元则输出非零元的值,不是非零元则输出“0”。
各元素之间用空格隔开。
最后输出完整的矩阵。
二、概要设计1.稀疏矩阵的抽象数据类型定义如下: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}基本操作:CreateSMatrix(&M);//建立稀疏矩阵MDestroySMatrix(&M);//销毁稀疏矩阵M;TransposeSMatrix(M);//求稀疏矩阵的转置矩阵AddSMatrix(&M,&N);//求稀疏矩阵M和N之和MulSMatrix(&M,&N);//求稀疏矩阵M和N之积}ADT SparseMatrix2、存储结构选择采用十字链表存储稀疏矩阵,它是稀疏矩阵链式表示的一种较好的表示方法。
课程设计实验报告 稀疏矩阵应用
![课程设计实验报告 稀疏矩阵应用](https://img.taocdn.com/s3/m/e4a9b324bcd126fff7050b29.png)
数据结构课程设计《数据结构》课程设计一.题目:稀疏矩阵应用(限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 函数以循环的方式比较非零元素是否为同一行列,如果是则两值相加,如果不是则把第二个元素加入链表中。
《数据结构 课程设计》稀疏矩阵实验报告
![《数据结构 课程设计》稀疏矩阵实验报告](https://img.taocdn.com/s3/m/14677c2a2af90242a895e574.png)
目录一、概述 (1)二、系统分析 (1)三、概要设计 (1)(1)主界面的设计: (2)(2)系数矩阵的存储 (2)(3)具体实现流程图: (3)四、详细设计 (4)(2)稀疏矩阵的相加: (5)五、运行与测试 (8)六、总结与心得 (9)参考文献 (9)源代码 (9)一、概述稀疏矩阵的加法运算,既将稀疏矩阵A和B,他均为m行n列,分别以数组的形式存放在A和B中,实现A+B=C,将所得的结果存放在C数组中。
二、系统分析稀疏矩阵的保存:以一位数组顺序存放非零元素的行号、列号和数值,行号为-1作为结束符。
以三个一维数组存放一个系数矩阵中的一个非零元素,为零额元素则不保存。
用一个二重循环来实现判断每个系数矩阵的非零元素是否为零,不为零,就将其行列下标和其值存入一维数组中稀疏矩阵的相加:用循环来判断存储A何B稀疏矩阵的两个一维数组中的行列下标是否相等和其大小关系。
若相等,则将两个一维数组的第三个元素的值相加存入新的数组C里,行列下标不变的存入进去;若A的列小于B的列,则将A的三个元素直接存入C中;若B的列小于A的列,则将B的三个元素村日C中;若A的行小于B的行,则将A的三个元素存入C中;若A的行大于B的行,则将B存入C中。
三、概要设计(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如下: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。
稀疏矩阵PPT课件
![稀疏矩阵PPT课件](https://img.taocdn.com/s3/m/164e032d793e0912a21614791711cc7931b778e1.png)
02
03
优化存储结构
并行计算
采用稀疏矩阵的压缩存储方式, 减少存储空间占用,提高数据访 问速度。
利用多核处理器和分布式计算资 源,实现并行计算,提高计算速 度。
线性系统求解优化
预处理技术
采用预处理技术,如共轭梯度法、双共轭梯度法 等,减少迭代次数和计算量。
迭代算法
选择适合的迭代算法,如雅可比迭代法、高斯-赛 德尔迭代法等,提高求解速度。
研究现状
随着大数据和计算技术的发展,稀疏矩阵在许多领域如机器学习、图像处理、数值计算 等得到了广泛应用。目前,稀疏矩阵的研究主要集中在算法优化、存储压缩和并行计算
等方面。
挑战
尽管取得了一些进展,但稀疏矩阵的研究仍面临诸多挑战。例如,如何更有效地压缩存 储稀疏矩阵以提高计算效率,如何设计更高效的算法处理大规模稀疏矩阵等问题仍需进
稀疏矩阵PPT课件
• 稀疏矩阵简介 • 稀疏矩阵的压缩方法 • 稀疏矩阵的运算优化 • 稀疏矩阵库介绍 • 稀疏矩阵应用案例 • 总结与展望
01
稀疏矩阵简介
定义与特性
定义
稀疏矩阵是一种矩阵,其中大部分元 素为零。
特性
稀疏矩阵具有稀疏性,即矩阵中非零 元素的数量远小于矩阵元素总数。
稀疏矩阵的应用场景
MATLAB中的稀疏矩阵处理
MATLAB是一个广泛使用的科学 计算软件,支持丰富的矩阵和向 量操作、数值计算和科学计算等
功能。
MATLAB提供了多种工具箱和函 数用于处理稀疏矩阵,如 spalloc、spdiags等。
MATLAB的语法简单易懂,易于 学习和使用,同时具有高效的性
能和可视化能力。
05
02
稀疏矩阵的压缩方法
数据结构——稀疏矩阵运算器
![数据结构——稀疏矩阵运算器](https://img.taocdn.com/s3/m/0c1cc6bde43a580216fc700abb68a98271feac6f.png)
数据结构——稀疏矩阵运算器数据结构——稀疏矩阵运算器1、简介1.1 背景稀疏矩阵是一种特殊的矩阵,其中包含大量的零元素。
与密集矩阵相比,稀疏矩阵在存储和计算上具有更高的效率。
稀疏矩阵运算器是一种特定的工具,用于执行稀疏矩阵的各种运算,如加法、减法、乘法等。
1.2 目的2、稀疏矩阵的定义与表示2.1 稀疏矩阵的定义稀疏矩阵是指在矩阵中只有部分元素非零的矩阵。
通常,如果矩阵中超过一定比例的元素为零,则可以将其称为稀疏矩阵。
2.2 稀疏矩阵的表示稀疏矩阵可以使用多种表示方式,如数组、链表、三元组等。
每种表示方式都有各自的特点和适用范围。
3、稀疏矩阵运算的基本概念3.1 稀疏矩阵加法稀疏矩阵加法是指对两个稀疏矩阵进行元素级别的相加操作。
该操作要求两个矩阵具有相同的维度。
3.2 稀疏矩阵减法稀疏矩阵减法是指对两个稀疏矩阵进行元素级别的相减操作。
该操作要求两个矩阵具有相同的维度。
3.3 稀疏矩阵乘法稀疏矩阵乘法是指对两个稀疏矩阵进行矩阵乘法运算。
该操作要求第一个矩阵的列数等于第二个矩阵的行数。
4、稀疏矩阵运算器的实现4.1 基本功能稀疏矩阵运算器应具备稀疏矩阵加法、减法和乘法的基本功能。
用户可以输入矩阵的维度和元素值,然后执行相应的运算。
4.2 稀疏矩阵的表示与存储稀疏矩阵的表示与存储是稀疏矩阵运算器的关键部分。
可以使用多种数据结构来表示和存储稀疏矩阵,如三元组、链表等。
4.3 稀疏矩阵运算的算法实现稀疏矩阵运算的算法实现是稀疏矩阵运算器的核心部分。
可以使用各种算法来实现稀疏矩阵的加法、减法和乘法运算。
5、附加功能与性能优化5.1 稀疏矩阵转置稀疏矩阵转置是指将稀疏矩阵的行与列进行交换。
该操作可以提高计算效率,并减少存储空间的使用。
5.2 稀疏矩阵的压缩与解压缩稀疏矩阵的压缩与解压缩是指将稀疏矩阵的存储空间进行优化,从而减少存储空间的使用。
5.3 算法的优化与性能测试稀疏矩阵运算器的性能优化是一个重要的方向。
数据结构稀疏矩阵应用
![数据结构稀疏矩阵应用](https://img.taocdn.com/s3/m/2d53981c6c175f0e7cd137ee.png)
实验五数组的运算实验目的:掌握稀疏矩阵的压缩存储方法及主要运算的实现。
实验内容与要求:设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行两个矩阵相加;⑷求一个矩阵的转置矩阵。
程序代码:#include<stdio.h>#define smax 20typedef int datatype;typedef struct{ int i,j;datatype v;}node;typedef struct{ node data[smax];int m,n,t;}spmatrix;void creat(spmatrix a)\\创建输出稀疏矩阵{ int k=0;printf("请输入稀疏矩阵:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[k].v!=0)\\以0元素作为结束标志,因为稀疏矩阵不包含0元素{k++;scanf("%d,%d,%d",&a.data[k].i,&a.data[k].j,&a.data[k].v);}printf("输出的稀疏矩阵是:\n");printf("%d,%d,%d\n",a.m,a.n,a.t);for(k=0;k<a.t;k++)\\一维数组思想,用for循环简单printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);printf("\n");}void transpose(spmatrix a)\\转置函数{ int p,q,k=0;printf("请输入稀疏矩阵:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[k].v!=0){k++;scanf("%d,%d,%d",&a.data[k].i,&a.data[k].j,&a.data[k].v);}for(k=0;k<a.t;k++)\\行列交换即可,但没有进行排序输出{p=a.data[k].i;a.data[k].i=a.data[k].j;a.data[k].j=p;}printf("输出转置后的初步矩阵元素:\n");for(k=0;k<a.t;k++)printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);for(p=0;p<a.t;p++)\\冒泡排序法,对转置后的稀疏矩阵进行重新排序for(k=0;k<(a.t-p);k++){if(a.data[k].i>a.data[k+1].i || (a.data[k].i==a.data[k+1].i &&a.data[k].j>a.data[k+1].j)){q=a.data[k].i;a.data[k].i=a.data[k+1].i;a.data[k+1].i=q;q=a.data[k].j;a.data[k].j=a.data[k+1].j;a.data[k+1].j=q;q=a.data[k].v;a.data[k].v=a.data[k+1].v;a.data[k+1].v=q;}}printf("输出转置后的稀疏矩阵:\n");printf("%d,%d,%d\n",a.n,a.m,a.t);for(k=1;k<(a.t+1);k++)\\此处下标加1是根据输出结果判定而来,不知道原因printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);printf("\n");}void add(spmatrix a,spmatrix b)\\求和函数{spmatrix c;int x=0,y=0,z=0;int p,q,r=0;printf("请输入稀疏矩阵a:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[x].v!=0){x++;scanf("%d,%d,%d",&a.data[x].i,&a.data[x].j,&a.data[x].v);}printf("请输入稀疏矩阵b:\n");scanf("%d,%d,%d",&b.m,&b.n,&b.t);scanf("%d,%d,%d",&b.data[0].i,&b.data[0].j,&b.data[0].v);while(a.data[y].v!=0){y++;scanf("%d,%d,%d",&b.data[y].i,&b.data[y].j,&b.data[y].v);}\\以上为重新创建两个稀疏矩阵,方便运算if(a.m==b.m && a.n==b.n)\\首先行列相等的稀疏矩阵才能相加{for(x=0;x<a.t;x++){c.data[z].i=a.data[x].i;c.data[z].j=a.data[x].j;c.data[z].v=a.data[x].v;z++;}for(y=0;y<a.t;y++){c.data[z].i=b.data[y].i;c.data[z].j=b.data[y].j;c.data[z].v=b.data[y].v;z++;}\\两个for循环先后把a,b两个稀疏矩阵元素放到一个新的稀疏矩阵c里去printf("输出结合后的初步稀疏矩阵C的元素:\n");\\进行一次打印for(z=0;z<(a.t+b.t);z++)printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);for(p=0;p<(a.t+b.t);p++)\\冒泡排序法对新矩阵元素排序for(z=0;z<(a.t+b.t-p);z++){if(c.data[z].i>c.data[z+1].i || (c.data[z].i==c.data[z+1].i &&c.data[z].j>c.data[z+1].j))\\有这几种情况需要重新排序,首先是进行行对比(前行大于后行进行交换),然后当行相等时在进行列对比(前列大于后列时在进行交换),其他情况均不用交换{q=c.data[z].i;c.data[z].i=c.data[z+1].i;c.data[z+1].i=q;q=c.data[z].j;c.data[z].j=c.data[z+1].j;c.data[z+1].j=q;q=c.data[z].v;c.data[z].v=c.data[z+1].v;c.data[z+1].v=q;}}printf("输出排序后的稀疏矩阵C的元素:\n");\\进行一次打印for(z=1;z<(a.t+b.t+1);z++)printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);for(z=1;z<(a.t+b.t+1-r);z++)\\主循环,保证阅读每一个数组元素if(c.data[z].i==c.data[z+1].i && c.data[z].j==c.data[z+1].j) \\在对排好序后的矩阵进行相等行列元素的合并{c.data[z].v=c.data[z].v+c.data[z+1].v;r++;\\此处是关键,记录此时的步骤,如果进行一次运算后,那么后面的循环就要少一次,包括再回到主循环时也要少一次for(z+1;(z+1)<(a.t+b.t+1-r);z++)\\小循环是让后面的每一个数组元素向前移动一个位置,掩盖掉相等行列元素{c.data[z+1].i=c.data[z+2].i;c.data[z+1].j=c.data[z+2].j;c.data[z+1].v=c.data[z+2].j;}}printf("输出最终结果的稀疏矩阵C:\n");printf("%d,%d,%d\n",a.m,a.n,(a.t+b.t-r));\\输出稀疏矩阵表头时只需将行列元素交换输出即可,元素个数输出时要注意相等行列元素合并进行了几次操作,即用r记录操作步骤的次数,每进行一次操作那么最终稀疏矩阵就少一个数组元素,同时r又是伴随步骤增加的for(z=1;z<(a.t+b.t+1-r);z++)\\原理同上printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);}Else\\给出稀疏矩阵表开头行列总和不等时则无法计算printf("输入的稀疏矩阵a,b不是行列相等的矩阵。
数据结构课程设计-稀疏矩阵
![数据结构课程设计-稀疏矩阵](https://img.taocdn.com/s3/m/967d3c1c4028915f814dc223.png)
数据结构课程设计报告设计题目:稀疏矩阵专业:计算机科技院系:计算机学院姓名:xxxxxxx学号:xxxxxxxx时间:2013年9月22日目录一需求分析---------------------------------------------------------------- 31.问题描述-------------------------------------------------------------------------------------- 32.基本要求-------------------------------------------------------------------------------------- 33 实现提示-------------------------------------------------------------------------------------- 3二概要设计----------------------------------------------------------------------3三详细设计----------------------------------------------------------------------4四调试分析-------------------------------------------------------------------- 10五用户手册---------------------------------------------------------------------11一需求分析1.【问题描述】稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间,提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
数据结构+课程设计+稀疏矩阵的操作(计算机学院)
![数据结构+课程设计+稀疏矩阵的操作(计算机学院)](https://img.taocdn.com/s3/m/62e538ee551810a6f52486ea.png)
计算机科学技术学院学生课程设计(论文)题目:学生姓名:学号:所在院(系):专业:班级:指导教师:职称:年月日计算机科学技术学院本科学生课程设计任务书注:任务书由指导教师填写。
课程设计(论文)指导教师成绩评定表稀疏矩阵的操作1.课程设计的目的本课程设计是为了配合《数据结构》课程的开设,通过设计一完整的程序,使学生掌握数据结构的应用、算法的编写、类C语言的算法转换成C程序并用TC上机调试的基本方法。
利用三元组实现稀疏矩阵的有关算法。
2.问题描述2.1稀疏矩阵采用三元组表示,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C。
2.2求出A的转置矩阵D,输出D。
3. 基本要求稀疏矩阵是指那些多数元素为零的矩阵。
利用“稀疏”特点进行存储和计算可以大大节省存储空间,提高计算效率。
实现一个能进行稀疏矩阵基本运算的运算器。
以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加、相减和相乘的运算。
稀疏矩阵的输入形式采用三元组表示,而运算结果的矩阵则通常以阵列形式列出。
4.结构设计4.1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加、相减和相乘的运算。
4.2.稀疏矩阵的输入形式采用三元组表示,而运算结果的矩阵则通常以阵列形式列出。
4.3.首先应输入矩阵的行数和列数,并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。
可设矩阵的行数和列数均不超过20。
4.4.程序可以对三元组的输入顺序加以限制,例如,按行优先。
注意研究教材的算法,以便提高计算效率。
5.在用三元组表示稀疏矩阵时,相加或相减所得结果矩阵应该另生成,乘积矩阵也可用二维数组存放5.算法思想5.1.主函数设置循环和选择语句进行运算循环和选择,进行稀疏矩阵的加法,减法,乘法,转置和是否继续运算5个分支开关进行运算选择。
5.2.设置函数分别实现稀疏矩阵的输入,输出,加法,减法,乘法。
5.3.在数组结构体中设置存放每行第一个非零元在其数组存储结构单元的位置的存储单元,若该行无非零元,则存为06.模块划分6.1typedef struct存放各行第一个非零元在存储数组中的位置,若该行无非零元,则其rpos[]值为零6.2 createsmatrix(rlsmatrix *M) 矩阵输入函数,输入各行非零元及其在矩阵中的行列数6.3 FasttransposeRLSMatrix(RLSMatrix M,RLSMatrix *Q) 矩阵快速转置6.4 HeRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q) 矩阵求和6.5 ChaRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q) 矩阵求差6.6 JiRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q) 矩阵求积7.算法实现7.1首先定义非零元个数的最大值和存放各行第一个非零元在存储数组中的位置#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; /* 矩阵的行数、列数和非零元个数*//* 各列第一个非零元的位置表rpos[0]未用*/}rlsmatrix;7.2创建稀疏矩阵矩阵的行数,列数,和非零元素的个数并按行序顺序输入第%d 个非零元素所在的行(1~%d),列(1~%d),元素值。
数据结构--稀疏矩阵课程设计
![数据结构--稀疏矩阵课程设计](https://img.taocdn.com/s3/m/2fc1542abed5b9f3f80f1c00.png)
安徽理工大学数据结构课程设计说明书题目: 稀疏矩阵的运算院系:计算机科学与工程学院专业班级:计算机10-*班学号: 201030****学生姓名: ******指导教师:2011年 12 月 28 日安徽理工大学课程设计(论文)任务书计算机科学与工程学院学号201030**** 学生姓名***** 专业(班级)计10-* 设计题目稀疏矩阵的运算设计技术参数系统平台:Windows XP开发工具:Microsoft Visual C++ 6.0设计要求(1)存储结构选择三元组存储方式;(2)实现一个稀疏矩阵的转置运算;(3)实现两个稀疏矩阵的加法运算;(4)实现两个稀疏矩阵的减法运算;(5)实现两个稀疏矩阵的乘法运算。
工作量课程设计报告要求不少于3000字。
源程序要求不少于300行工作计划11月9日-11月22日查找相关资料11月23日-11月26日 DOS菜单界面设计11月27日-12月5日设计算法12月6日-12月20日编写代码12月21日-12月28日撰写实验报告参考资料[1]秦锋.数据结构(C语言版).北京:清华大学出版社,2011[2]温秀梅,丁学均.Visual C++面向对象程序设计.北京:清华大学出版社,2009[3]何钦铭,颜晖.C语言程序设计.北京:高等教育出版社,2008指导教师签字教研室主任签字2011年 11 月 8 日安徽理工大学课程设计(论文)成绩评定表学生姓名:***** 学号:201030**** 专业班级:计10-* 课程设计题目:稀疏矩阵的运算指导教师评语:成绩:指导教师:年月日目录1 问题描述 (1)2 需求分析 (1)3 总体设计 (2)3.1 Matrix结构的定义 (2)3.2 系统流程图 (3)4 详细设计 (4)4.1 “菜单”界面 (4)4.2 建立矩阵 (4)4.3 显示矩阵 (6)4.4 矩阵的转置 (7)4.5 矩阵的加法运算 (8)4.6 矩阵的减法运算 (9)4.7 矩阵的乘法运算 (10)5 程序运行 (11)5.1 输入矩阵 (11)5.2 矩阵转置 (11)5.3 矩阵加法 (12)5.4 矩阵减法 (12)5.5 矩阵乘法 (13)5.6 退出及错误提示 (13)6 总结 (14)参考文献 (15)1 问题描述(1)题目内容:设计稀疏矩阵运算系统实现两个稀疏矩阵的加法、减法、乘法以及转置操作。
课程设计 稀疏矩阵应用
![课程设计 稀疏矩阵应用](https://img.taocdn.com/s3/m/d1d7368fd0d233d4b14e694e.png)
数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 8404181题目: 稀疏矩阵应用年级/专业/班:学生姓名:学号:开始时间:2011 年06 月13日完成时间:2011 年06月21 日课程设计成绩:学习态度及平时成绩(30)技术水平与实际能力(20)创新(5)说明书撰写质量(45)总分(100)指导教师签名:年月日目录1 引言 (1)1.1问题的提出 (1)1.2国内外研究的现状 (1)1.3任务与分析 (1)2 程序的主要功能 (1)2.1三元组的转置 (1)2.2三元组的加法 (1)2.3三元组的减法 (1)2.4三元组的乘法 (2)2.5十字链表的转置 (2)2.6十字链表的加法 (2)2.7十字链表的减法 (2)2.8十字链表的乘法 (2)3程序运行平台 (3)4总体设计 (3)5程序类的说明 (4)6 模块分析 (5)6.1三元组的转置 (5)6.2三元组减法 (6)6.3三元组的减法 (9)6.4三元组的乘法 (12)6.5十字链表的转置 (14)6.6十字链表的加法 (15)6.7十字链表的减法 (18)6.8十字链表的乘法 (22)7 系统测试 (25)7.1三元组的转置 (25)7.2三元组的加法 (26)7.3三元组的减法 (26)7.4三元组的乘法 (27)7.5十字链表的转置 (27)7.6十字链表的加法 (28)7.7十字链表的减法 (28)7.8十字链表的乘法 (29)7.9总结 (29)8结论 (29)参考文献 (29)摘要随着计算机的普及,一句话引出题目…(小四楷体_GB2312),分析了三元组和十字链表的存储和各种运算的实现,利用C语言编程实现了稀疏矩阵的运算系统,该系统具有三元组十字链表存储下的稀疏矩阵转置、加法、减法、乘法的功能。
关键词:稀疏矩阵;计算机; 运算器1 引言1.1 问题的提出矩阵是很多科学与工程计算问题中研究的数学对象。
数据库课程设计—— 稀疏矩阵
![数据库课程设计—— 稀疏矩阵](https://img.taocdn.com/s3/m/f27a812a915f804d2b16c1be.png)
目录1 设计题目......................................... 错误!未定义书签。
1.1 任务....................................... 错误!未定义书签。
1.3 输入....................................... 错误!未定义书签。
1.4 输出....................................... 错误!未定义书签。
2.概要设计........................................ 错误!未定义书签。
2.1 数据需求分析............................... 错误!未定义书签。
2.2 功能需求分析............................... 错误!未定义书签。
2.3 数据结构设计............................... 错误!未定义书签。
2.3.1 ADT描述.............................. 错误!未定义书签。
3.详细设计........................................ 错误!未定义书签。
3.1各个程序的实现图............................ 错误!未定义书签。
3.2 源程序设计................................. 错误!未定义书签。
4.调试分析........................................ 错误!未定义书签。
4.1 程序运行截图5.设计总结........................................ 错误!未定义书签。
参考文献........................................... 错误!未定义书签。
稀疏矩阵的操作课程设计
![稀疏矩阵的操作课程设计](https://img.taocdn.com/s3/m/19a517c97375a417876f8f7d.png)
摘要随着科学技术的飞速发展,人类的生活工作方式发生了很大的改变,工作效率随着高科技的加入有了质的提高,特别是信息技术和网络技术的迅速发展和广泛应用,对社会的政治,经济,军事,文化等领域产生越来越深刻的影响。
现代生活各个方面都离不开计算机技术,而C是国际上广泛流行的通用程设语言,在计算机的研究和应用中以展现强大的生命力。
C功能强大,使用灵活,既具有高级语言的特点,又具有低级语言的些特点;它既可用于编写系统软件又可用于编写应用软件。
本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。
在程序设计中,采用了先用三元组实现稀疏矩阵的输入,输出,及其转置,相加,相乘操作的方法。
程序通过调试运行,结果与预期一样,初步实现了设计目标。
关键词:稀疏矩阵,三元组,链表I目录摘要 (I)1 课程设计的目的和意义 (1)2 需求分析 (1)2.1需求概述 (1)2.2 需求环境 (2)3 系统功能设计及数据结构设计 (2)3.1模块设计 (2)3.2系统子程序及功能设计 (2)4 算法设计、数据流图及程序结构框图 (2)4.1 程序功能模块 (2)4.2 程序流程图 (4)5 程序原代码及其说明 (5)6 程序测试及运行结果说明 (10)7 总结 (14)主要参考资料 (14)1 课程设计的目的和意义通过本课程设计教学所要达到的目的是:培养学生用学到的书本知识解决实际问题的能力;培养实际工作所需要的动手能力;培养学生以科学理论和工程上能力的技术,规范地开发大型、复杂、高质量的应用软件和系统软件具有关键性作用;通过课程设计的实践,学生可以在程序设计方法、上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
2 需求分析2.1需求概述1. 问题描述设计程序用十字链表实现稀疏矩阵的加、乘、转置。
基本功能要求:(1) 稀疏矩阵采用三元组表示,求两个具有相同行列数的稀疏矩阵A 和B的相加矩阵C ,并输出C 。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构课程设计报告题目:十字链表成为存储结构,实现稀疏矩阵的求和运算****:**班级:软件三班学号:****************: ***一、需求分析1.问题描述:要求:十字链表下的稀疏矩阵的加、转、乘的实现。
2.基本功能实现十字链表下的转置,乘法,加法运算。
3.输入输出(1)设计函数建立稀疏矩阵,初始化值。
(2)设计函数输出稀疏矩阵的值。
(3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。
(4)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。
(5)构造函数进行稀疏矩阵的转置,并输出结果。
(6)退出系统。
二、概要设计1.设计思路:本实验要求在三元组,十字链表下实现稀疏矩阵的加、转、乘。
首先要进行矩阵的初始化操作,定义三元组和十字链表的元素对象。
写出转置,加法,乘法的操作函数。
通过主函数调用实现在一个程序下进行矩阵的运算操作。
2.数据结构设计:抽象数据类型稀疏矩阵的定义如下:ADT SparseMatrix{数据对象:D={aij | i=1,2,…,m; j=1,2,..,n;aij∈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}基本操作:CreateSMatrix(&M);操作结果:创建稀疏矩阵M。
DestroySMatrix(&M);初始条件:稀疏矩阵M存在。
操作结果:销毁稀疏矩阵M。
PrintSMatrix(M);初始条件:稀疏矩阵M存在。
操作结果:输出稀疏矩阵M。
AddSMatrix(M,N,&Q);初始条件:稀疏矩阵M与N的行数和列数对应相等操作结果:求稀疏矩阵的和Q=M+N。
MultSMatrix(M,N,&Q);初始条件:稀疏矩阵M的列数等于N的行数。
操作结果:求稀疏矩阵乘积Q=M*N。
TransposeSMatrix(M,&T);初始条件:稀疏矩阵M存在。
操作结果:求稀疏矩阵M的转置矩阵T。
}ADT SparseMatrix3.软件结构设计:(1)主程序模块:Void main(){初始化;do {接受命令;处理命令;}while(“命令”=“退出”);}(2)稀疏矩阵模块{实现矩阵的相加bool AddSMatrix();实现矩阵的相乘bool MultSMatrix();实验矩阵的转置bool TransposeSMatrix();}(3)十字链表模块{创建十字链表bool CreateSMatrix_OL(CrossList & M);输出十字链表bool OutPutSMatrix_OL(CrossList T);}(4)主程序模块稀疏矩阵模块十字链表模块三、详细设计1. 定义程序中所有用到的数据及其数据结构,及其基本操作的实现;typedef struct {int i, j;int e;} Triple; // 定义三元组的元素typedef struct {Triple data[MAXSIZE + 1];int mu, nu, tu;} TSMatrix; // 定义普通三元组对象typedef struct {Triple data[MAXSIZE + 2];int rpos[MAXROW + 1];int mu, nu, tu;} RLSMatrix; // 定义带链接信息的三元组对象typedef struct OLNode { // 定义十字链表元素int i, j;int e;struct OLNode *right, *down; // 该非零元所在行表和列表的后继元素} OLNode, *OLink; // 定义十字链表元素typedef struct { // 定义十字链表对象结构体OLink *rhead, *chead;int mu, nu, tu; // 系数矩阵的行数,列数,和非零元素个数} CrossList; // 定义十字链表对象结构体2.主函数int main(){int t;cout.fill('*');cout << setw(80) << '*';cout.fill(' ');cout << setw(50) << "***欢迎使用矩阵运算程序***" << endl; //输出头菜单 cout.fill('*');cout << setw(80) << '*';cout.fill(' ');cout << " 请选择要进行的操作:" << endl;cout << " 1:矩阵的转置。
" << endl;cout << " 2:矩阵的加法。
" << endl;cout << " 3:矩阵的乘法。
" << endl;cout << " 4:退出程序。
" << endl;while(t){cout<<"请输入您要进行的操作:"<<endl;cin>>t;switch(t){case 1:TransposeSMatrix(); //调用矩阵转置函数break;case 2:AddSMatrix(); //调用矩阵相加函数break;case 3:MultSMatrix(); //调用矩阵相乘函数break;case 4:t=0;break;}}return 0;}矩阵的转置函数bool TransposeSMatrix() // 求矩阵的转置矩阵{TSMatrix M, T; //定义预转置的矩阵InPutTSMatrix(M, 0); //输入矩阵int num[MAXROW + 1];int cpot[MAXROW + 1]; // 构建辅助数组int q, p, t;T.tu = M.tu;T.mu = M.nu;T.nu = M.mu;if (T.tu){for (int 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 (int i = 2; i <= M.nu; i++) cpot[i] = cpot[i - 1] + num[i - 1]; // 求出每一列中非零元素在三元组中出现的位置for (p = 1; p <= M.tu; p++){int 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];}}cout << "输入矩阵的转置矩阵为" << endl;OutPutSMatrix(T);return true;}bool Count(RLSMatrix &T) {int num[MAXROW + 1];for (int row = 1; row <= T.mu; row++) num[row] = 0;for (int col = 1; col <= T.tu; col++) ++num[T.data[col].i];T.rpos[1] = 1;for (int i = 2; i <= T.mu; i++) T.rpos[i] = T.rpos[i - 1] + num[i - 1]; // 求取每一行中非零元素在三元组中出现的位置return true;}矩阵的乘法函数bool MultSMatrix() // 两个矩阵相乘{RLSMatrix M, N, Q; // 构建三个带“链接信息”的三元组表示的数组InPutTSMatrix(M, 1); // 用普通三元组形式输入数组InPutTSMatrix(N, 1);Count(M);Count(N);cout << "输入的两矩阵的乘矩阵为:" << endl;if (M.nu != N.mu) return false;Q.mu = M.mu;Q.nu = N.nu;Q.tu = 0; // Q初始化int ctemp[MAXROW + 1]; // 辅助数组int arow, tp, p, brow, t, q, ccol;if (M.tu * N.tu) // Q是非零矩阵{for (arow = 1; arow <= M.mu; arow++){///memset(ctemp,0,N.nu);for (int x = 1; x <= N.nu; x++) // 当前行各元素累加器清零ctemp[x] = 0;Q.rpos[arow] = Q.tu + 1; // 当前行的首个非零元素在三元组中的位置为此行前所有非零元素+1if (arow < M.mu) tp = M.rpos[arow + 1];else tp = M.tu + 1;for (p = M.rpos[arow]; p < tp; p++) // 对当前行每个非零元素进行操作{brow = M.data[p].j; // 在N中找到i值也操作元素的j值相等的行if (brow < N.mu) t = N.rpos[brow + 1];else t = N.tu + 1;for (q = N.rpos[brow]; q < t; q++) // 对找出的行当每个非零元素进行操作{ccol = N.data[q].j;ctemp[ccol] += M.data[p].e * N.data[q].e; // 将乘得到对应值放在相应的元素累加器里面}}for (ccol = 1; ccol <= Q.nu; ccol++) // 对已经求出的累加器中的值压缩到Q中if (ctemp[ccol]){if (++Q.tu > MAXSIZE) return false;Q.data[Q.tu].e = ctemp[ccol];Q.data[Q.tu].i = arow;Q.data[Q.tu].j = ccol;}}}OutPutSMatrix(Q);return true;}矩阵的加法函数bool AddSMatrix() //矩阵的加法{CrossList M, N; // 创建两个十字链表对象,并初始化CreateSMatrix_OL(M);CreateSMatrix_OL(N);cout << "输入的两矩阵的和矩阵为:" << endl;OLink pa, pb, pre, hl[MAXROW + 1]; //定义辅助指针,pa,pb分别为M,N当前比较的元素,pre为pa的前驱元素for (int x = 1; x <= M.nu; x++) hl[x] = M.chead[x];for (int k = 1; k <= M.mu; k++) // 对M的每一行进行操作{pa = M.rhead[k];pb = N.rhead[k];pre = NULL;while (pb) // 把N中此行的每个元素取出{OLink p;if (!(p = (OLink) malloc(sizeof (OLNode)))) exit(0); // 开辟新节点,存储N中取出的元素p->e = pb->e;p->i = pb->i;p->j = pb->j;if (NULL == pa || pa->j > pb->j) // 当M此行已经检查完或者pb因该放在pa前面{if (NULL == pre)M.rhead[p->i] = p;elsepre->right = p;p->right = pa;pre = p;if (NULL == M.chead[p->j]) // 进行列插入{M.chead[p->j] = p;p->down = NULL;}else{p->down = hl[p->j]->down;hl[p->j]->down = p;}hl[p->j] = p;pb = pb->right;}elseif ((NULL != pa) && pa->j < pb->j) // 如果此时的pb元素因该放在pa后面,则取以后的pa再来比较{pre = pa;pa = pa->right;}elseif (pa->j == pb->j) // 如果pa,pb位于同一个位置上,则将值相加{pa->e += pb->e;if (!pa->e){ // 如果相加后的和为0,则删除此节点,同时改变此元素坐在行,列的前驱元素的相应值if (NULL == pre) // 修改行前驱元素值M.rhead[pa->i] = pa->right;elsepre->right = pa->right;p = pa;pa = pa->right;if (M.chead[p->j] == p) M.chead[p->j] = hl[p->j] = p->down; // 修改列前驱元素值elsehl[p->j]->down = p->down;free(p);pb = pb->right;}else{pa = pa->right;pb = pb->right;}}}}OutPutSMatrix_OL(M);return true;}创建十字链表bool CreateSMatrix_OL(CrossList & M)// 创建十字链表{int x, y, m;cout << "请输入矩阵的行,列,及非零元素个数" << endl;cin >> M.mu >> M.nu >> M.tu;if (!(M.rhead = (OLink*) malloc((M.mu + 1) * sizeof (OLink)))) exit(0); if (!(M.chead = (OLink*) malloc((M.nu + 1) * sizeof (OLink)))) exit(0); for (x = 0; x <= M.mu; x++)M.rhead[x] = NULL; // 初始化各行,列头指针,分别为NULLfor (x = 0; x <= M.nu; x++)M.chead[x] = NULL;cout << "请按三元组的格式输入数组:" << endl;for (int i = 1; i <= M.tu; i++){cin >> x >> y >> m; // 按任意顺序输入非零元,(普通三元组形式输入) OLink p, q;if (!(p = (OLink) malloc(sizeof (OLNode)))) exit(0); // 开辟新节点,用来存储输入的新元素p->i = x;p->j = y;p->e = m;if (M.rhead[x] == NULL || M.rhead[x]->j > y){p->right = M.rhead[x];M.rhead[x] = p;}else{for (q = M.rhead[x]; (q->right) && (q->right->j < y); q = q->right); // 查找节点在行表中的插入位置p->right = q->right;q->right = p; // 完成行插入}if (M.chead[y] == NULL || M.chead[y]->i > x){p->down = M.chead[y];M.chead[y] = p;}else{for (q = M.chead[y]; (q->down) && (q->down->i < x); q = q->down); // 查找节点在列表中的插入位置p->down = q->down;q->down = p; // 完成列插入}}return true;}十字链表的输出bool OutPutSMatrix_OL(CrossList T)// 输出十字链表,用普通数组形式输出{for (int i = 1; i <= T.mu; i++){OLink p = T.rhead[i];for (int j = 1; j <= T.nu; j++){if ((p) && (j == p->j)){cout << setw(3) << p->e;p = p->right;} elsecout << setw(3) << "0";}cout << endl;}return true;}3.主要函数的程序流程图,实现设计中主程序和其他子模块的算法,以流程图的形式表示。