稀疏矩阵三元组存储转置后矩阵输出
稀疏矩阵三元组快速转置（转poklau123写的很清楚）
稀疏矩阵三元组快速转置（转poklau123写的很清楚）
关于稀疏矩阵的快速转置法，⾸先得明⽩其是通过对三元表进⾏转置。如果误以为是对矩阵进⾏转置，毫⽆疑问就算你想破脑袋也想不出个所以然，别陷⼊死胡同了！
对于⼀个三元表，⾏为i，列为j，值为v。需将其i与j的值对调才能得到新的三元表，但是如果直接进⾏转换，得到的新的三元表的顺序是混乱的，不符合三元表的规则。所以，课本⾸先介绍了⼀个⽤扫描来转置的算法（这个算法⽐较容易，在这⾥我就不说了），但是这个转置算法的时间复杂度太⾼，于是就有了接下来的快速转置算法。
要你对⼀个三元表进⾏步骤最少的转置，你可能会想，如果知道三元表中每⼀项在转置后的新的三元表中的位置，然后直接放进去，岂不是极⼤的缩⼩了时间复杂度？没错！快速转置法正是基于这种思想⽽设计的。
那么如何知道三元表中某⼀项的位置呢？在课本98页的a.data这个三元表可以看到，j为列号，在转置后即为新的三元表的⾏号，三元表正是按照⾏序进⾏排列的，⽽j=1有2个、j=2有2个、j=3有2个、j=4有1个、j=6有1个。根据这些数据按照从⼩到⼤排列，j=1的项在新的三元表中应占据第1、2位，j=2的项在新的三元表中应占据第3、4位，j=3的项在新的三元表中应占据第5、6位，j=4应占据第7位，j=6应占据第8位。
接下来就轻松多了，转置的时候直接从第⼀项读起，读取其j值，⽐如课本中a.data这个三元表的第⼀项的j值为2,因为j=2占据第3、4位，所以应该从第三位开始放，接下来如果读取的某⼀项的j值也是2,就放在第4位。因为j=2的项只有两个，所以第5位绝对不会被j=2的项占据，第5、6项本来就是留给j=3的。再⽐如当读到j=6的那项时，第8位是留给它的，就可以直接放进第8位了。这样，读取每⼀项，都能在三元表中找到相应的位置，这就是稀疏矩阵快速转置的原理。
稀疏矩阵快速转置
题目：假设稀疏矩阵A采用三元组表表示，编写程序实现该矩阵的快速转置
要求：输入一个稀疏矩阵A，由程序将其转换成三元组表存储；转置后的三元组表，由程序将其转换成矩阵形式后输出。
二、概要设计
⒈为实现上述算法，需要线性表的抽象数据类型：
ADT SparseMatrix {
数据对象：D={a
ij :|a
ij
∈TermSet,i=1…m,m≥0，j=1…n,n≥0 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 }
基本操作:
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(){
初始化；
{
接受命令；
显示结果；
｝
｝
⑵矩阵压缩存储单元模块：实现链表抽象数据类型操作，即函数的定义模块；
三、详细设计
⒈元素类型，结点类型
typedef struct {
int i,j;
稀疏矩阵三元组实现矩阵转置算法实验报告
稀疏矩阵三元组实现矩阵转置算法实验
报告
实验三稀疏矩阵的三元组表示实现矩阵转置算法
学院专业班
学号姓名
实习目的
掌握稀疏矩阵的三元组顺序表存储表示；
掌握稀疏矩阵三元组表示的传统转置算法的实现；
掌握稀疏矩阵三元组表示的快速转置算法的实现；
实习内容
稀疏矩阵的按三元组形式输入，即按行序输入非零元的行号、列号、值，实现传统转置算法，输出按通常的阵列形式输出。
稀疏矩阵的按三元组形式输入，即按行序输入非零元的行号、列号、值，实现快速转置算法，输出按通常的阵列形式输出。
实验步骤
三元组的定义
#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; // 矩阵的行数、列数和非零元个数
};
创建稀疏矩阵M （按三元组形式输入，即按行序输入非零元的行号、列号、值）
3. 编写三元组传统转置函数。
4. 编写三元组快速转置函数。
4. .主函数
(1)程序代码
#include "stdio.h"
#include "stdlib.h"
#define MAX_SIZE 100 // 非零元个数的最大值
Typedef int ElemType;
struct Triple
{
int i,j; // 行下标,列下标
稀疏矩阵存储和操作稀疏矩阵的数据结构与算法
稀疏矩阵存储和操作稀疏矩阵的数据结构与
算法
稀疏矩阵是指具有大量零元素和少量非零元素的矩阵。在实际场景中，由于矩阵中大部分元素为零，传统的矩阵存储方式会造成大量的存储空间的浪费以及数据操作的低效性。因此，为了节省存储空间和提高数据操作的效率，稀疏矩阵的存储和操作需要借助于特定的数据结构和算法。
一、稀疏矩阵存储的数据结构
1.1. 压缩存储方法
压缩存储方法是一种常用的稀疏矩阵存储方法。常见的压缩存储方法有三种：行压缩法（CSR）、列压缩法（CSC）和十字链表法。
1.1.1. 行压缩法（CSR）
行压缩法是通过两个数组来存储稀疏矩阵的非零元素。第一个数组存储非零元素的值，第二个数组存储非零元素在矩阵中的位置信息。
1.1.
2. 列压缩法（CSC）
列压缩法与行压缩法相似，只是存储方式不同。列压缩法是通过两个数组来存储稀疏矩阵的非零元素。第一个数组存储非零元素的值，第二个数组存储非零元素在矩阵中的位置信息。
1.1.3. 十字链表法
十字链表法是一种更加灵活的稀疏矩阵存储方法。通过使用链表的
方式，将非零元素存储在链表中，并且每个非零元素还具有行和列的
指针，方便进行数据操作。
1.2. 坐标存储法
坐标存储法是一种简单直观的稀疏矩阵存储方法。每个非零元素包
括行列坐标和元素值，通过三元组的方式进行存储。
二、稀疏矩阵的操作算法
2.1. 矩阵转置
矩阵转置是指将原矩阵的行变为列，列变为行的操作。对于稀疏矩阵，常用的转置算法为快速转置算法。该算法通过统计每列非零元素
的个数，并根据列的非零元素个数确定每个非零元素转置后的位置。
稀疏矩阵快速转置算法
稀疏矩阵快速转置算法
稀疏矩阵快速转置算法是一种用于高效地将稀疏矩阵进行转置的算法。稀疏矩阵是指其中大部分元素为零的矩阵。
下面是一种常见的稀疏矩阵快速转置算法，称为CRS（Compressed Row Storage）格式：
1. 首先，遍历原始矩阵，统计每列非零元素的个数，并记录每个非零元素在转置后矩阵中的位置。
2. 创建一个长度为列数的数组col_ptr，用于记录每一列非零元素在转置后矩阵中的起始位置。
3. 初始化col_ptr数组，使得col_ptr[i]表示第i列在转置后矩阵中的起始位置，初始值为0。
4. 再次遍历原始矩阵，将每个非零元素按照其在转置后矩阵中的位置放入对应的位置。
对于原始矩阵中的每个非零元素A[i][j]，找到其在转置后矩阵中的位置，即col_ptr[j] + 1，将该元素放入转置后矩阵的该位置。
更新col_ptr[j]，使其加1，以便下一个非零元素能够放入正确的位置。
5. 完成转置后，得到转置后的稀疏矩阵。
这种算法的时间复杂度为O(n + nz)，其中n是原始矩阵的列数，nz是原始矩阵的非零元素个数。该算法通过压缩存储和避免无效操作，能够高效地进行稀疏矩阵的转置。
1
数据结构稀疏矩阵试验报告
数据结构与算法
的课程设计
课程设计题目：数据结构的稀疏矩阵转置算法
院系名称：信息技术学院
专业（班级）：10级计算机本（2）班
姓名：
学号：
指导教师：
实验内容：
矩阵的快速转置：假设稀疏矩阵A采用三元组表表示，编写程序实现该矩阵的快速转置。
要求：输入一个稀疏矩阵A，由程序将其转换成三元组表存储；转置后的三元组表，由程序将其转换成矩阵形式后输出。
1.需求分析
（1）输入矩阵A[M][N]用三元组表存储为a，将三元组组a转置为b，最后将三元组b转换成矩阵的形式输出
（2）程序的命令包括：
a.构建一个三元组a
b.用快速转置法将a转置成b
c.将转置后的三元组b转换成矩阵后输出
2.概要设计：
（1）为实现上述算法，需要三元组的抽象数据类型：
ADT SparseMatrix{
数据对象：D={a
ij
|i=1,2,...,m; j=1,2,...,n;
a
ij
∈ElemSet, m 和n分别称为矩阵的行数和列数} 数据关系：R={Row，Col}
Row={
i,j ,a
i,j+1
>|1
Col={
i,j ,a
i,j+1
>|1
基本操作：
Creat（&a）;
操作结果：创建稀疏矩阵a。
trans(a, &b)
初始条件：稀疏矩阵a存在。
操作结果：将稀疏矩阵a转置后存储在b中。
print(Tsmatrix *T)
初始条件：稀疏矩阵已经存在。
操作结果：将稀疏矩阵转换成矩阵的形式输出。
(2)程序的主要模块
主程序模块
main(){
初始化；
｛接受命令；
显示结果；
}
｝
矩阵压缩存储单元模块：实现链表抽象数据类型操作，即函数的定义模块。
3.详细设计
三元组压缩存储结构的稀疏矩阵的运算快速转置
三元组压缩存储结构的稀疏矩阵的运算快速转置
在计算机科学和数学领域中，稀疏矩阵是一种在大部分元素为零的矩阵。由于其大部分元素为零，因此在存储和运算时存在着一些挑战。为了解决这一问题，人们提出了三元组压缩存储结构，这种存储结构能够有效地压缩稀疏矩阵，并且能够实现快速的运算转置。
1.稀疏矩阵
稀疏矩阵是一种大部分元素为零的矩阵，与之相对应的是稠密矩阵，其大部分元素为非零值。稀疏矩阵通常在图像处理、文本处理、网络分析等领域中得到广泛应用。然而，由于大部分元素为零，传统的存储方式会导致存储空间的浪费。人们提出了三元组压缩存储结构，以解决稀疏矩阵存储的问题。
2.三元组压缩存储结构
三元组压缩存储结构是一种用于表示稀疏矩阵的存储格式。它采用三个数组来分别存储矩阵的非零元素的行坐标、列坐标和数值。由于只需存储非零元素的信息，因此能够有效地压缩存储空间。三元组压缩存储结构还能够实现快速的随机访问，这是由于它将矩阵的元素位置和数值分开存储，使得在进行运算时能够更为高效。
3.稀疏矩阵的运算
稀疏矩阵的运算是对稀疏矩阵进行加法、减法、乘法等操作的过程。
在进行稀疏矩阵的运算时，三元组压缩存储结构能够显著提高计算效率。这是由于在进行运算时，只需考虑非零元素，而无需考虑大量的
零元素，从而减少了计算的复杂度。
4.稀疏矩阵的快速转置
稀疏矩阵的转置是将矩阵的行和列交换，同时保持非零元素的位置和
数值不变。在传统的存储方式下，稀疏矩阵的转置操作相对复杂且耗时。然而，采用三元组压缩存储结构后，稀疏矩阵的快速转置变得十
分简便。通过交换三元组中的行坐标和列坐标，即可完成稀疏矩阵的
稀疏矩阵三元组实验报告
一、设计人员相关信息
1.设计者姓名、学号和班号：12地信李晓婧12012242983
2.设计日期：2014.
3.上机环境：VC++6.0
二、程序设计相关信息
1.实验题目：实验题6.4 假设n*n的稀疏矩阵A采用三元组表示，设计一个程序实现
如下功能：（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组。
| 1 0 3 1 |
| 0 1 0 0 |
| 0 0 1 0 |
| 0 0 1 1 |
2.实验项目组成：
（1）生成稀疏矩阵三元组；（2）输出转置矩阵三元组
3.实验项目的程序结构（程序中的函数调用关系图）：
4.实验项目包含的各个文件中的函数的功能描述：
CreatMat：对一个二维稀疏矩阵创建其三元组表示，以行序方式扫描二维稀疏矩阵A，将其非零的元素插入到三元组t中。
DispMat：输出三元组。从头到尾扫描三元组t，依次输出元素值。
TranMat：矩阵转置。对一个m*n的矩阵A m*n，其转置矩阵是一个n*m的矩阵，设为
B n*m，满足a i，j=b i，j，其中0≤i≤m-1，0≤j≤n-1。
5.算法描述或流程图：
6.实验数据和实验结果：
7.出现的问题及解决方案
主函数缺少一次输出，稀疏矩阵没有显示。
解决方案：主函数加一个输出稀疏矩阵disp（A）。
三、程序盘
提交的程序盘应包含全部的源程序清单和可执行文件。
三元组法存储稀疏矩阵
三元组法存储稀疏矩阵
稀疏矩阵是指其中大部分元素都为0的矩阵。在计算机科学中，稀疏矩阵可以使用三元组法进行存储，以节省内存空间。
三元组法是指将稀疏矩阵中非零元素的行、列和值依次存储在一个三元组中。具体来说，对于一个m行n列的稀疏矩阵A，可以使用一个大小为k*3的三元组T来存储。其中，k是非零元素的个数。三元组T中的每一行即可表示一个非零元素的位置和值。
例如，对于如下的3*3稀疏矩阵：
| 0 0 0|
| 0 5 0|
| 0 0 0|
其三元组表示如下：
| 2 2 5|
其中，第一列表示非零元素在第2行，第二列表示非零元素在第2列，第三列表示非零元素的值为5。
三元组法的优点在于节省了内存空间，并且存储和访问操作较为高效。但是，对于密集矩阵来说，使用三元组法存储反而会更加浪费空间。
关于如何将稀疏矩阵转换为三元组，可以采用行逐一法或列逐一法。对于行逐一法，可以先确定每一行非零元素的个数，然后按照行的顺序依次存储对应的三元组。对于列逐一法，可以先确定每一列非零元素的个数，然后按照列的顺序依次存储对应的三元组。
总之，三元组法是一种方便高效的稀疏矩阵存储方式。在实际应用中，可以根据具体情况选择是否采用该方法。
实现稀疏矩阵(采用三元组表示)的基本运算实验报告
实现稀疏矩阵（采用三元组表示）的基本运算实验报告
一实验题目: 实现稀疏矩阵（采用三元组表示）的基本运算二实验要求:
（1）生成如下两个稀疏矩阵的三元组 a 和 b；（上机实验指导 P92 ）（2）输出 a 转置矩阵的三元组；
（3）输出a + b 的三元组；
（4）输出 a * b 的三元组；
三实验内容:
稀疏矩阵的抽象数据类型:
ADT SparseMatrix {
数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;
ai,j∈ElemSet,m和n分别称为矩阵的行数和列数}
数据关系: R={ Row , Col }
Row ={<ai,j ,ai,j+1> | 1≤i≤m , 1≤j ≤n-1}
Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}
基本操作:
CreateSMatrix(&M)
操作结果：创建稀疏矩阵 M PrintSMatrix(M)
初始条件：稀疏矩阵M已经存在
操作结果：打印矩阵M DestroySMatrix(&M)
初始条件：稀疏矩阵M已经存在
操作结果：销毁矩阵M CopySMatrix(M, &T)
初始条件：稀疏矩阵M已经存在
操作结果：复制矩阵M到T
AddSMatrix(M, N, &Q)
初始条件：稀疏矩阵M、N已经存在
操作结果：求矩阵的和Q=M+N
SubSMatrix(M, N, &Q)
初始条件：稀疏矩阵M、N已经存在
操作结果：求矩阵的差Q=M-N TransposeSMatrix(M, & T)
三元组表示稀疏矩阵转置
三元组表示稀疏矩阵转置
随着时代的进步，互联网已经深入到了我们的各个层面，其成功的关键之一就
在于数据处理技术。稀疏矩阵转置是构成这一技术的基础之一，主要目的是改变二维矩阵的行和列。这里要介绍的是一种特殊的“三元组表示稀疏矩阵转置”技术，它可以更加高效地将变换后的矩阵存储在硬盘上以便以后可以重用。
三元组表示稀疏矩阵转置处理的思路是，首先，将需要转置的稀疏矩阵以一个“非零元素”列表的形式读入，记为(row,col,data),其中row表示该非零元素所
处的行数，col表示列数，data表示该非零元素的值；然后，根据row和col的值，计算变换后的稀疏矩阵的最终坐标依次给出(col,row)；最后，将所有非零元素的
坐标以及对应的值，按照升序排序，用“三元组表示形式”写入硬盘中以作备份。
三元组表示稀疏矩阵转置也是一种特殊的“非零元素”列表构建技术。它把矩
阵转换成一系列索引型(index type)的非零元素数据，这既可以更加有效地把变换后的矩阵存储起来，也可以有效地提高运算效率，避免无谓的存储和消耗。
从长远来看，三元组表示稀疏矩阵转置无疑是一种重要的数据技术，它的成功
不仅取决于它的有效简便度，而且取决于它有助于改善计算处理效率，提高输出效果，从而使数据技术更为可靠，有助于推动信息革命更大范围的发展。
稀疏矩阵csr计算方式
稀疏矩阵csr计算方式
稀疏矩阵是指具有大量零元素的矩阵。在计算机科学中，稀疏矩阵的存储和计算是非常重要的问题。其中，CSR (Compressed Sparse Row) 是一种最常用的稀疏矩阵存储格式之一。
CSR 矩阵的计算方式是通过三个数组来表示稀疏矩阵。这三个数组分别为：
1. 矩阵值数组 (values)：用于存储矩阵中非零元素的值；
2. 列标识符数组 (columns)：用于存储矩阵中非零元素所在的列的位置；
3. 行偏移数组 (row_ptr)：用于存储每一行第一个非零元素在values 数组中的位置。
通过这三个数组，我们可以轻松地实现稀疏矩阵的矩阵乘法、向量乘法等计算操作。
具体地，CSR 矩阵的矩阵乘法计算方式如下：
1. 对于矩阵 A 和矩阵 B，首先将 B 转置为 B'；
2. 遍历 A 的每一行，在 row_ptr 数组中找到该行的起始位置和终止位置；
3. 对于该行的每一个非零元素，找到其对应的列标识符和值；
4. 在 B' 中找到该列的起始位置和终止位置；
5. 对于该列的每一个非零元素，找到其对应的行标识符和值；
6. 将该行的值和该列的值相乘并累加到结果矩阵 C 中。
通过以上步骤，即可实现 CSR 矩阵的矩阵乘法计算。相比于一
般的矩阵乘法计算方式，CSR 矩阵的计算方式能够更加高效地处理稀疏矩阵，从而提高计算速度和效率。
最常用的稀疏矩阵
最常用的稀疏矩阵
稀疏矩阵是一种在计算机科学和数学中用于处理大规模稀疏数据
集的数据结构。稀疏矩阵的特点是其中大部分元素为零，而非零元素
只占据矩阵中的一小部分位置。在实际应用中，稀疏矩阵在减少存储
空间和计算时间方面具有重要意义。本文将介绍最常用的稀疏矩阵存
储格式和应用领域。
在介绍最常用的稀疏矩阵存储格式之前，我们需要了解什么是稀
疏矩阵及其特点。一个稀疏矩阵是一个矩阵，其中大多数元素为零。
一般来说，当一个矩阵中的非零元素的数量少于矩阵中元素总数的一
半时，我们就认为这是一个稀疏矩阵。相比于密集矩阵，稀疏矩阵可
以以更少的存储空间表示和处理。
稀疏矩阵的存储格式有多种，其中最常用的有三种：压缩稀疏行（CSR）、压缩稀疏列（CSC）和三元组（COO）。这些存储格式的选择
通常取决于具体的应用场景和操作需求。
首先是压缩稀疏行（Compressed Sparse Row）存储格式，也称为CSR存储格式。在CSR存储格式中，我们使用三个数组来表示稀疏矩阵。
第一个数组称为values数组，存储所有非零元素的值。第二个数组称为columns数组，存储所有非零元素所在的列号。第三个数组称为row_ptr数组，存储每一行第一个非零元素在values和columns数组中的索引。通过这种方式，我们可以有效地存储稀疏矩阵，并且可以快速地访问非零元素和执行矩阵向量乘法等操作。
其次是压缩稀疏列（Compressed Sparse Column）存储格式，也称为CSC存储格式。与CSR存储格式类似，CSC存储格式也使用三个数组来表示稀疏矩阵。但是，这里的数组有些不同。values数组存储所有非零元素的值。rows数组存储所有非零元素所在的行号。col_ptr 数组存储每一列第一个非零元素在values和rows数组中的索引。与CSR存储格式相比，CSC存储格式在执行某些操作时可能更有效。
存储稀疏矩阵
存储稀疏矩阵
稀疏矩阵是一种特殊的矩阵，它的大部分元素都是0。在实际应用中，很多矩阵都具有稀疏性质，即只有少数非零元素。如果对这些矩阵进行普通的存储，会占用大量的存储空间，而且对矩阵的运算和处理也会变得非常低效。为了解决这个问题，人们发展出了一种专门用于存储稀疏矩阵的方法，即稀疏矩阵存储。
稀疏矩阵存储的核心思想是只存储矩阵中非零元素的值以及它们的位置信息，而对于零元素则不进行存储。这种存储方式可以大大节省存储空间，提高计算效率。下面我们将介绍两种常用的稀疏矩阵存储方法：压缩稀疏矩阵存储和链表稀疏矩阵存储。
1. 压缩稀疏矩阵存储
压缩稀疏矩阵存储是一种基于数组的存储方法。它将稀疏矩阵转换为一个三元组表，其中每个非零元素都由三个值组成：行号、列号和元素值。通过这种方式，我们可以只存储非零元素的信息，从而减少存储空间的占用。同时，由于元素的位置信息也被存储下来，我们可以方便地进行稀疏矩阵的运算和处理。
2. 链表稀疏矩阵存储
链表稀疏矩阵存储是一种基于链表的存储方法。它将稀疏矩阵转换为一个链表，其中每个非零元素都被存储为一个节点，节点包含了行号、列号和元素值。通过链表的方式，我们可以动态地添加和删
除节点，而不需要预先分配存储空间。这种存储方法在处理稀疏矩阵时非常灵活，尤其适用于那些元素数量不确定的情况。
除了上述两种常用的存储方法外，还有一些其他的稀疏矩阵存储方法，如哈希表存储和位图存储。这些方法都有各自的特点和适用范围，可以根据实际情况选择合适的存储方法。
稀疏矩阵存储在很多领域都有广泛的应用。比如，在图像处理中，很多图像都是稀疏的，只有少数像素点是非零的。通过稀疏矩阵存储，我们可以有效地表示和处理这些图像，从而实现高效的图像处理算法。另外，在网络分析和推荐系统中，稀疏矩阵存储也被广泛应用。通过存储用户与物品之间的关系矩阵，我们可以进行用户推荐和相似度计算等任务。
三元组结构实现稀疏矩阵转置算法的分析
三元组结构实现稀疏矩阵转置算法的分析
文章简要叙述了稀疏矩阵压缩存储的三元组表示法及其基于此种结构的矩阵的转置运算。探讨了基于三元组结构的矩阵转置算法的具体实现方法及其时空复杂度的问题。
【关键词】稀疏矩阵压缩存储三元组转置算法
在一些特殊矩阵中，如对称矩阵和上下三角矩阵，非零元素一般都有明显的规律，从而都可以压缩到一维数组里面，然而，实际应用中经常会遇到这样一些矩阵，它们非零元素少，且分布不均匀，且没有明显的规律，称之为稀疏矩阵。按照压缩存储的思想，只需存储矩阵中的非零元素。为了便于存取和检索，一般在存储的时候必须带有合适的辅助信息，即同时记录下它所在的行列的位置等等。在实际应用中，一般我们采取的是用三元组和十字链表两种表示方法来实现稀疏矩阵的存储及其运算。稀疏矩阵在数值计算、电力系统的潮流计算、天气预报、工程分析计算等方面都有着大量的应用，不少实际问题都可以转化为对稀疏矩阵的计算问题。了解稀疏矩阵的各种操作变得尤为重要。
1 基本概念
设矩阵中有t个非零元素，若t远远小于矩阵元素的总数，则称该矩阵为稀疏矩阵。通常，在m×n 的矩阵中，存在t个非零元素。设δ= t/（m*n），则称δ为矩阵的稀疏
因子，一般认为当δ≤0.05时为稀疏矩阵。在存储稀疏矩阵时，为了节约存储单元，很自然的压缩方法就是只存储非零元素，但由于非零元素的分布一般是没有规律的，因此在存储非零元素的同时，还必须存储相应的辅助信息，才能准确迅速确定一个非零元素是矩阵中的哪一个元素。最简单的办法就是将非零元素的值和它所在的行列号作为一个结点存放到一起，于是矩阵中的每一个非零元素就由一个三元组（i，j，aij）唯一确定。显然，稀疏矩阵的压缩存储方法会让其失去随机存取功能。
稀疏矩阵 存储方法
稀疏矩阵存储方法
存储稀疏矩阵的一种常见方法是使用三元组表示法（Triplet representation）。
三元组表示法包含三个数组（或链表），分别存储非零元素的行下标、列下标和对应的值。具体来说，假设稀疏矩阵的大小为m行n列，其中包含k个非零元素，那么三元组表示法的结构如下：
1. 一个长度为k的数组row_index，用于存储非零元素的行下标。
2. 一个长度为k的数组col_index，用于存储非零元素的列下标。
3. 一个长度为k的数组value，用于存储非零元素的值。
这样，对于稀疏矩阵中的每一个非零元素，可以通过三个数组的对应位置来获取其行下标、列下标和值。
使用三元组表示法的优点是可以节省存储空间，因为只需要存储非零元素的信息，而对于零元素可以省略。另外，由于三元组表示法是按照元素出现的顺序存储的，可以方便地遍历稀疏矩阵的非零元素。
然而，三元组表示法也存在一些限制，比如在插入或删除元素时可能需要移动大量的元素位置，效率较低。因此，在实际应用中，还存在其他更加高效的存储方法，比如压缩稀疏行（Compressed Sparse Row，CSR）和压缩稀疏列
（Compressed Sparse Column，CSC）等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
void FastTransposeTSMatrix(TSMatrix A,TSMatrix *B)
{
int col,t,p,q;
int num[MAXSIZE],position[MAXSIZE];
B->len=A.len;
B->n=A.m;
B->m=A.n;
if(B->len)
clrscr();
creatTSMatrix(&A);
FastTransposeTSMatrix(A,&B);
visit(&B);
getch();
}
}
}
}
void visit(TSMatrix *B)
{
int row,col,p=1;
int d;
printf("the transposed Triple translate into Matrix is:\n");
for(row=1;row<=B->m;row++)
{ printf("\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;
#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 1000
typedef int ElementType;
typedef struct
{
int row,col;
ElementType e;
}Triple;
typedef struct
{Leabharlann Baidu
Triple data[MAXSIZE+1];
for(col=1;col<=B->n;col++)
{ if(B->data[p].row==row&& B->data[p].col==col)
{ d=B->data[p].e;
p++;
}
else d=0;
printf("%6d",d);
}
}
}
main()
{
TSMatrix A;
TSMatrix B;
{
for(col=1;col<=A.n;col++){num[col]=0;}
for(t=1;t<=A.len;t++)
{num[A.data[t].col]++;}
position[1]=1;
for(col=2;col<=A.n;col++)
position[col]=position[col-1]+num[col-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);
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");
for(p=1;p<=A.len;p++)
{
col=A.data[p].col;
q=position[col];
B->data[q].row=A.data[p].col;
B->data[q].col=A.data[p].row;
B->data[q].e=A.data[p].e;
position[col]++;