稀疏矩阵的行压缩存储(CRS)

合集下载

稀疏矩阵的压缩存储

稀疏矩阵的压缩存储

稀疏矩阵的压缩存储稀疏矩阵的压缩存储:实现稀疏矩阵压缩存储,并实现矩阵转置和求和。

输⼊矩阵时,⾸先需要输⼊⾮零元素的个数,然后分别输⼊矩阵的⾏号,列号和值。

输完2个矩阵后,⾃动进⾏计算第⼀个矩阵的转置以及两个矩阵的和。

例如:输⼊如下:100 90 5 //矩阵的⾏数为100,列数为90,共5个⾮零元素。

1 10 100 //a(1,10)=10050 60 200//a(50,60)=20050 80 100//a(50,80)=10060 60 200//a(60,60)=20099 89 10//a(99,89)=10100 90 2 //矩阵b的⾏数为100,列数为90,共2个⾮零元素。

1 1 10 //b(1,1)=1050 60 -200//b(50,60)=-200#include <iostream>using namespace std;struct Triple { //三元组int Row, Col; //⾮零元素⾏号/列号int value; //⾮零元素的值void operator = (Triple & R) //赋值{Row = R.Row; Col = R.Col; value = R.value;}};class SparseMatrix {private: //a = a*bint Rows, Cols, Terms; //⾏/列/⾮零元素数Triple *smArray; //三元组表public:SparseMatrix(int maxSize=100); //构造函数void Transpose(SparseMatrix& B); //转置SparseMatrix Add(SparseMatrix& b); //a = a+bfriend ostream& operator << (ostream& out, SparseMatrix &M);friend istream& operator >> (istream& in, SparseMatrix &M);};SparseMatrix::SparseMatrix(int maxSize){Terms = maxSize;smArray = new Triple[maxSize];Rows = Cols = 0;};void SparseMatrix::Transpose(SparseMatrix & B){int *rowSize = new int[Cols]; //列元素数数组int *rowStart = new int[Cols]; //转置位置数组B.Rows = Cols; B.Cols = Rows;B.Terms = Terms;if (Terms > 0) {int i, j;for (i = 0; i < Cols; i++) rowSize[i] = 0;for (i = 0; i < Terms; i++)rowSize[smArray[i].Col]++;rowStart[0] = 0;for (i = 1; i < Cols; i++)rowStart[i] = rowStart[i - 1] + rowSize[i - 1];for (i = 0; i < Terms; i++) {j = rowStart[smArray[i].Col];B.smArray[j].Row = smArray[i].Col;B.smArray[j].Col = smArray[i].Row;B.smArray[j].value = smArray[i].value;rowStart[smArray[i].Col]++;}}delete[] rowSize; delete[] rowStart;}SparseMatrix SparseMatrix::Add(SparseMatrix & b){SparseMatrix res;int i = 0, j = 0, index_a, index_b;res.Terms = 0;while (i < Terms&&j < b.Terms) {index_a = Cols * smArray[i].Row + smArray[i].Col;index_b = Cols * b.smArray[j].Row + b.smArray[j].Col;if (index_a < index_b) {res.smArray[res.Terms] = smArray[i];i++;}else if (index_a > index_b) {res.smArray[res.Terms] = b.smArray[j];j++;}else{int vv= smArray[i].value + b.smArray[j].value;if (vv != 0) {res.smArray[res.Terms] = smArray[i];res.smArray[res.Terms].value = vv;}if (vv == 0) {res.Terms--;}i++; j++;}res.Terms++;}for (; i < Terms; i++) {res.smArray[res.Terms] = smArray[i];res.Terms++;}for (; j < b.Terms; j++) {res.smArray[res.Terms] = b.smArray[j];res.Terms++;}return res;}ostream & operator<<(ostream & out, SparseMatrix & M){for (int i = 0; i < M.Terms; i++) {out << M.smArray[i].Row << " " << M.smArray[i].Col << " " << M.smArray[i].value << endl; }return out;// TODO: 在此处插⼊ return 语句}istream & operator>>(istream & in, SparseMatrix & M){in >> M.Rows >> M.Cols >> M.Terms;for (int i = 0; i < M.Terms; i++) {in >> M.smArray[i].Row >> M.smArray[i].Col >> M.smArray[i].value;}return in;// TODO: 在此处插⼊ return 语句}int main(){SparseMatrix s,s2,s3,s4;cin >> s;cin >> s3;s.Transpose(s2);cout << "The transformed matrix is:" << endl;cout << s2;s4=s.Add(s3);cout << "The added matrix is:" << endl;cout << s4;return 0;}。

稀疏矩阵的压缩存储方法与应用场景

稀疏矩阵的压缩存储方法与应用场景

稀疏矩阵的压缩存储方法与应用场景稀疏矩阵指的是矩阵中绝大部分元素为0的情况下,只保存非零元素及其对应的坐标的一种存储方式。

相比于一般的矩阵存储方式,稀疏矩阵的压缩存储方法可以有效节省存储空间,并提高运算效率。

本文将介绍一些常见的稀疏矩阵的压缩存储方法以及其应用场景。

一、行压缩存储法(CRS)行压缩存储法(CRS,Compressed Row Storage)是一种经典的稀疏矩阵压缩存储方法。

在CRS中,矩阵的非零元素按行优先的顺序存储,并记录每行非零元素的开始位置及其列号。

由于CRS只存储非零元素及其对应的行列坐标,因此可以大大减少存储空间。

CRS适用于行操作较多的场景,比如图像处理、有限元分析等。

在这些场景下,常常需要对稀疏矩阵进行行操作,例如行相加、行相减、行乘以常数等。

CRS可以通过迅速定位非零元素所在的行并对其进行操作,提高计算效率。

二、列压缩存储法(CCS)列压缩存储法(CCS,Compressed Column Storage)是另一种常见的稀疏矩阵压缩存储方法。

在CCS中,矩阵的非零元素按列优先的顺序存储,并记录每列非零元素的开始位置及其行号。

与CRS相比,CCS可以更加高效地进行列操作,如列相加、列相减、列乘以常数等。

CCS常用于图论、网络分析等领域。

例如,在图论中,常常需要对邻接矩阵进行列操作,如计算图的邻接节点、计算图的度数等。

CCS 可以快速对非零元素所在的列进行操作,提高计算效率。

三、对角线压缩存储法(Diagonal Storage)对角线压缩存储法是一种适用于具有特殊结构的稀疏矩阵的压缩存储方法。

在对角线压缩存储法中,只存储矩阵的非零主对角线元素以及非零副对角线元素,其余元素均为0。

通过存储非零对角线元素及其位置,可以进一步减少存储空间。

对角线压缩存储法适用于具有对称或反对称性质的矩阵。

在数值计算、网络传输等领域,经常需要处理对称或反对称矩阵。

对角线压缩存储法可以有效存储这类特殊结构的矩阵,并提高运算效率。

稀疏矩阵 存储方法

稀疏矩阵 存储方法

稀疏矩阵存储方法稀疏矩阵是指矩阵中绝大部分元素为0的矩阵。

在实际问题中,往往会遇到大规模的稀疏矩阵,对于这种矩阵的存储需要考虑如何高效地使用内存空间。

下面将介绍几种常见的稀疏矩阵存储方法。

1. 链接存储法:在这种方法中,我们可以使用一个链表来存储非零元素的位置和值。

具体做法是每个非零元素都使用一个结点来表示,结点中包括行、列和对应的元素值。

这样,对于每个非零元素,我们只需要包含它的位置信息和值即可,并且可以通过遍历链表来获取所有的非零元素。

2. 顺序表存储法:在顺序表存储法中,我们使用两个数组来保存非零元素的位置和值。

一个一维数组存储所有非零元素的位置,另一个一维数组存储对应的值。

在这种方法中,我们需要额外的辅助空间来保存非零元素的位置信息,但是对于获取元素值的操作会更加高效,因为我们可以直接通过索引来访问元素。

3. 排序顺序表存储法:与顺序表存储法类似,不同之处在于我们需要对非零元素的位置进行排序。

一种常见的排序方法是按照行优先顺序进行排序。

这样做的好处是在矩阵乘法运算等操作中,我们可以利用行优先的顺序,减少对非零元素的访问次数,从而提高运算效率。

4. 压缩存储法:在压缩存储法中,我们通过记录每行非零元素的数量以及每个非零元素的位置和值来表示稀疏矩阵。

具体做法是使用三个一维数组分别存储每行非零元素的数量、非零元素的列索引和对应的值。

这种方法可以极大地节省存储空间,并且对于访问非零元素的操作也很高效。

以上介绍的是几种常见的稀疏矩阵存储方法,它们各自的特点和适用场景也不同。

选择何种存储方法应该根据具体应用的需求来确定。

例如,在求解线性方程组或稀疏矩阵乘法运算时,可以选择压缩存储法;而在矩阵的插入、删除操作较为频繁时,可以考虑使用链表存储法。

总之,在实际应用中,我们需要根据问题的特点和存储空间的要求,综合考虑各种因素来选择最合适的存储方法。

稀疏矩阵csr存储规则

稀疏矩阵csr存储规则

稀疏矩阵csr存储规则
稀疏矩阵CSR存储规则。

稀疏矩阵是指大部分元素为零的矩阵,对于这种矩阵,传统的
存储方式会造成大量的存储空间浪费。

因此,稀疏矩阵CSR (Compressed Sparse Row)存储规则应运而生。

在CSR存储规则中,矩阵被分为三个数组来存储,值数组(values),列索引数组(col_index)和行偏移数组(row_ptr)。

这种存储方式可以大大减少存储空间的浪费,提高了矩阵的存储效率。

具体来说,值数组存储矩阵中非零元素的值,列索引数组存储
每个非零元素对应的列索引,而行偏移数组存储每一行的第一个非
零元素在值数组中的索引位置。

这样一来,我们可以通过行偏移数
组来确定每一行非零元素的位置,通过列索引数组找到对应的列索引,然后在值数组中找到具体的值。

通过CSR存储规则,我们可以高效地存储和检索稀疏矩阵的数据,减少存储空间的浪费,提高计算效率。

因此,在处理大规模稀
疏矩阵时,CSR存储规则是一种非常有效的存储方式。

总而言之,稀疏矩阵CSR存储规则通过将矩阵分解为值数组、列索引数组和行偏移数组,实现了对稀疏矩阵高效存储和检索的目的,为处理大规模稀疏矩阵提供了重要的技术支持。

稀疏数据处理方法

稀疏数据处理方法

稀疏数据处理方法
稀疏数据指的是在大型数据集中具有很少非零元素的数据。

这种数据在现实世界中很常见,比如社交媒体、物联网和生物信息学等领域。

由于数据的稀疏性,传统的数据处理方法难以处理,因此需要一些特殊的处理技术来处理这种数据。

1. 稀疏数据表示方法
在稀疏数据处理中,最常用的表示方法是稀疏矩阵。

稀疏矩阵是一个矩阵,其中大多数元素都是零。

为了节省空间和计算资源,只需要存储非零元素和它们的位置。

通常情况下,非零元素的数量远远少于矩阵中所有的元素。

2. 稀疏数据的压缩
稀疏数据的压缩是减少存储空间和计算资源的有效方法。

最常用的压缩方法是压缩稀疏行(CSR)和压缩稀疏列(CSC)。

在CSR中,矩阵的非零元素按行存储,每一行存储一个非零元素的位置和值。

在CSC中,矩阵的非零元素按列存储,每一列存储一个非零元素的位置和值。

这种压缩方法可以大幅减少存储空间的占用。

3. 稀疏数据的算法
由于稀疏数据的特殊性质,传统的数据处理算法难以直接适用于稀疏数据。

因此,需要一些特殊的算法来处理稀疏数据。

最常用的算法包括稀疏矩阵乘法、岭回归和最小角回归等。

稀疏矩阵乘法是在稀疏矩阵上进行的一种特殊乘法运算。

它的思想是利用稀疏矩阵的特殊性质,将运算速度提高到O(NlogN)或O(N)。

岭回归是一种用于处理线性回归的方法。

它通过加入一个惩罚因子来解决过拟合的问题,同时利用稀疏矩阵的特殊性质来加速计算。

最小角回归是一种用于处理多元线性回归的方法。

它可以处理大规模的稀疏数据,并具有很强的稳定性和精度。

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法

稀疏矩阵及其压缩存储方法1.基本概念稀疏矩阵(SparseMatrix):是矩阵中的一种特殊情况,其非零元素的个数远小于零元素的个数。

设m行n列的矩阵含t个非零元素,则称以二维数组表示高阶的稀疏矩阵时,会产生零值元素占的空间很大且进行了很多和零值的运算的问题。

特殊矩阵:值相同的元素或0元素在矩阵中的分布有一定的规律。

如下三角阵、三对角阵、稀疏矩阵。

压缩存储:为多个值相同的元素只分配一个存储空间;对0元素不分配空间。

目的是节省大量存储空间。

n x n的矩阵一般需要n2个存储单元,当为对称矩阵时需要n(1+n)/2个单元。

2.三元组顺序表——压缩存储稀疏矩阵方法之一(顺序存储结构)三元组顺序表又称有序的双下标法,对矩阵中的每个非零元素用三个域分别表示其所在的行号、列号和元素值。

它的特点是,非零元在表中按行序有序存储,因此便于进行依行顺序处理的矩阵运算。

当矩阵中的非0元素少于1/3时即可节省存储空间。

(1)稀疏矩阵的三元组顺序表存储表示方法#define MAXSIZE 12500 // 假设非零元个数的最大值为12500typedef struct {int i, j; // 该非零元的行下标和列下标ElemType e; //非零元素的值} Triple; // 三元组类型typedef union { //共用体Triple data[MAXSIZE + 1]; // 非零元三元组表,data[0]未用int mu, nu, tu; // 矩阵的行数、列数和非零元个数} TSMatrix; // 稀疏矩阵类型(2)求转置矩阵的操作◆用常规的二维数组表示时的算法for (col=1; col<=nu; ++col)for (row=1; row<=mu; ++row)T[col][row] = M[row][col];其时间复杂度为: O(mu×nu)◆用三元组顺序表表示时的快速转置算法Status FastTransposeSMatrix(TSMatrix M, TSMatrix &T) {// 采用三元组顺序表存储表示,求稀疏矩阵M的转置矩阵TT.mu = M.nu; 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];// 求M 中每一列所含非零元的个数cpot[1] = 1;for (col=2; col<=M.nu; ++col) cpot[col] = cpot[col-1] + num[col-1];// 求M 中每一列的第一个非零元在b.data 中的序号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];} // for} // ifreturn OK;} // FastTransposeSMatrix其时间复杂度为: O(mu +nu)3.行逻辑联接的顺序表——压缩存储稀疏矩阵方法之二(链接存储结构)行逻辑联接的顺序表:稀疏矩阵中为了随机存取任意一行的非0元素,需要知道每一行的第一个非0元素在三元组表中的位置,因此将上述快速转置算法中指示行信息的辅助数组cpot 固定在稀疏矩阵的存储结构中,让每一行对应一个单链表,每个单链表都有一个表头指针,这种“带行链接信息”的三元组表即称为行逻辑联接的顺序表。

csr读取稀疏矩阵

csr读取稀疏矩阵

csr读取稀疏矩阵1.引言1.1 概述概述部分的内容可以包括CSR格式和稀疏矩阵的基本概念和定义。

概述:CSR (Compressed Sparse Row) 格式是一种常用的稀疏矩阵存储格式,它通过压缩稀疏矩阵的行索引、列索引和非零元素值的方式,实现了对大规模稀疏矩阵的高效存储和读取。

稀疏矩阵是指矩阵中大部分元素为零的矩阵,与之相对的是稠密矩阵,即大部分元素都不为零。

在很多应用领域,如图像处理、机器学习和科学计算等,稀疏矩阵的表示和处理是非常重要的。

CSR格式最早由Yale大学的George K. Francis教授在1972年提出,在数值计算和稀疏矩阵计算领域得到了广泛应用。

相比于其他常见的稀疏矩阵存储格式,如COO (Coordinate) 格式和CSC (Compressed Sparse Column) 格式,CSR格式具有更高的存储效率和读取速度。

它通过将矩阵的非零元素按行顺序存储,并将每行的非零元素的列索引和值分别保存在两个数组中,大大节省了存储空间。

此外,CSR格式还支持快速的稀疏矩阵向量乘法等操作,是许多线性代数计算中的重要基础。

本文将介绍CSR格式在读取稀疏矩阵中的应用。

首先,我们将详细介绍CSR格式的原理和数据结构,并对其进行比较分析,了解其优势和不足之处。

然后,我们将探讨稀疏矩阵的定义和特点,从理论上认识稀疏矩阵的结构和特性,为后续的稀疏矩阵读取提供基础。

最后,我们将在结论部分总结CSR格式在读取稀疏矩阵中的优势和应用场景。

通过本文的阅读,读者将能够全面了解CSR格式在读取稀疏矩阵中的原理和应用,为进一步的研究和应用提供参考。

希望本文能够对读者在稀疏矩阵的处理和应用中起到一定的帮助和指导作用。

1.2文章结构文章结构是指文章的组织方式和章节的排列顺序。

一个良好的文档结构可以使读者更好地理解文章的主要内容和观点。

本文按照以下结构来组织:1. 引言1.1 概述1.2 文章结构1.3 目的2. 正文2.1 CSR格式介绍2.2 稀疏矩阵的定义和特点3. 结论3.1 CSR格式在读取稀疏矩阵中的应用3.2 总结在引言部分,我们将对文章要介绍的内容进行概述,简要说明CSR格式和稀疏矩阵,以及本文的目的。

稀疏矩阵的压缩存储上

稀疏矩阵的压缩存储上

第3讲 稀疏矩阵压缩存储上——教学讲义稀疏矩阵是指矩阵中大多数元素为零的矩阵。

从直观上讲,当非零元素个数低于总元素的30 %时,这样的矩阵为稀疏矩阵。

如下图所示的矩阵M 、 N 中,非零元素个数均为8个,矩阵元素总数均为6 ×7 =42 ,显然8 /42 <30 %,所以M 、 N 都是稀疏矩阵。

1 稀疏矩阵的三元组表表示法 ( 1 ) 稀疏矩阵的三元组存储表示对于稀疏矩阵的压缩存储,采取只存储非零元素的方法。

由于稀疏矩阵中非零元素aij 的分布没有规律 ,因此,要求在存储非零元素值的同时还必须存储该非零元素在矩阵中所处的行号和列号的位置信息,这就是稀疏矩阵的三元组表表示法。

每个非零元素在一维数组中的表示形式如下图所示。

说明:为处理方便,将稀疏矩阵中非零元素对应的三元组按“行序为主序”用一维结构体数组进行存放,将矩阵的每一行(行由小到大)的全部非零元素的三元组按列号递增存放。

由此得到矩阵M 、 N 的三元组表A 和B 。

如下图所示。

0 12 9 0 0 0 0 0 0 0 0 0 0 0 -3 0 0 0 0 14 0 0 0 24 0 0 0 0 0 18 0 0 0 0 0 15 0 0 -7 0 0 0M=6×7 0 0 -3 0 0 15 12 0 0 0 18 0 9 0 0 24 0 0 00 0 0 0 -7 0 0 0 0 0 0 00 14 0 0 0 00 0 0 0 07×6N= 稀疏矩阵M 和N三元组的结构( 2 )稀疏矩阵三元组表的类型定义 稀疏矩阵三元组表类型定义如下:#define MAXSIZE 1000 /*设非零元素的个数最多为1000*/ typedef struct { int row, col; /*该非零元素的行下标和列下标*/ ElementType e ; /*该非零元素的值*/ }Triple; typedef struct{ Triple data[MAXSIZE+1]; /* 非零元素的三元组表。

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

– Using CRS format to store a sparse matrix will save a lot of memory.
Compressed Row Storage
– val array stores the values of the nonzero elements in a row-wise fashion. – col_ind array stores the corresponding column indices of the elements in the val array.
•The value of nonzero elements of row i: val[ row_ptr[ i ] ], ... , val[ row_ptr[ i+1 ] -1 ]
//Compressed Row Storage format //for a sparse square (mSize X mSize) matrix public class CRS{ //the values of the nonzero elements of the matrix float[] val; //the column indices of the elements in val array int[] col_idx; //locations in the val and col_idx array that start a row int[] row_ptr; //the size of the matrix: the number of rows int mSize=0; //constructor that takes a sparse matrix and convert it to a CRS object CRS( float[][] matrix){... } //print the matrix in CRS format. public void printCRS(){... } //test the program public static void main(String[] args){... } }
CRS( float[][] matrix){ int i, j, index; //the total number of nonzero in the matrix int totalNonZeros; //get the number of rows and columns mSize = matrix.length;
0
2
5
16
val col_ind
10 1
-2 5
3 1
9 2
3 6
7 2
8 3
7 4
… …
4 2
2 5
ห้องสมุดไป่ตู้
-1 6
the number of nonzero elements in a matrix
row_ptr
0
2
5
8
12
16
19
the number of rows +1
•The number of nonzero elements of row i = row_ptr[i+1] - row_ptr[ i ]
//get the total number of nonzero entries in the matrix totalNonZeros = 0; for( i=0; i<mSize; i++){ for( j=0; j<mSize; j++){ if(matrix[i][j] != 0) totalNonZeros++; } } //allocate memory for val and col_idx array val = new float[ totalNonZeros ]; col_idx = new int[ totalNonZeros ]; //allocate memory for row_ptr row_ptr = new int[ mSize+1]; row_ptr[ 0 ] = 0;
val //store the matrix in CRS format
x x
...
index index = 0;// point to the next position to store the value for( i=0; i<mSize; i++ ){//each row for( j=0; j<mSize; j++ ){//each column if( matrix[i][j] != 0 ){ //add the value to val val[ index ] = matrix[ i ][ j ]; //record the column index in col_idx col_idx[ index ] = j; index++; } } //update row_ptr row_ptr[ i+1 ] = index; } }//end of CRS( float[][] matrix)
• E.g. col_ind[5] stores the column index of val[5].
– row_ptr array stores the locations in the val array and col_ind array that start a row.
0
1 2 3
4
5 0 1 2 3 4 5
//test the program public static void main(String[] args){ float[][] matrix = {{10, 0, 0, 0, -2, 0}, {3, 9, 0, 0, 0, 3}, {0, 7, 8, 7, 0, 0}, {3, 0, 8, 7, 5, 0}, {0, 8, 0, 9, 9, 13}, {0, 4, 0, 0, 2, -1}}; System.out.println("the original sparse matrix"); for(int i=0; i<6; i++){ for(int j=0; j<6; j++){ System.out.print(matrix[i][j]+", "); } System.out.println(); } System.out.println(); CRS crs = new CRS(matrix); crs.printMatrix(); crs.printCRS(); }
Lab 3
Why Compressed Row Storage
– A sparse matrix has a lot of elements of value zero. – Using a two dimensional array to store a sparse matrix wastes a lot of memory. – Compressed Row Storage (CRS) format only stores the nonzero elements.
相关文档
最新文档