矩阵压缩存储之稀疏矩阵详解（C语言版）

最新推荐文章于 2024-05-03 15:39:14 发布
最新推荐文章于 2024-05-03 15:39:14 发布
阅读量7.1k 收藏 154
点赞数 25
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44075108/article/details/115435408
版权

文章目录

一、定义

        矩阵中非零元素的个数远远小于矩阵元素的总数，并且非零元素的分布没有规律，通常认为矩阵中非零元素的总数比上矩阵所有元素总数的值小于等于0.05时，则称该矩阵为稀疏矩阵(sparse matrix)。

二、结构

        如何进行稀疏矩阵的压缩存储呢?
        按照压缩存储的概念，只存储稀疏矩阵的非零元。因此，除了存储非零元的值之外，还必须同时记下它所在行和列的位置( i，j )。反之，一个三元组(i，j，e)惟一确定了矩阵A的一个非零元。由此，稀疏矩阵可由表示非零元的三元组及其行列数惟一确定。

#define ElemType int //矩阵内的数据类型
#define MAXSIZE 100   //矩阵内最大元素个数

//三元组结构
typedef struct Triple
{
	int i;  //元素所在行
	int j;  //元素所在列
	ElemType e;  //元素值
}Triple;

//稀疏矩阵
typedef struct SMatrix
{
	Triple data[MAXSIZE]; // 0 三元组，存放有效数据
	int mu; //稀疏矩阵行数
	int nu; //稀疏矩阵列数
	int tu; //非零元素个数
}SMatrix;

三、常用操作

1. 创建稀疏矩阵

通过文件创建稀疏矩阵

//通过文件创建稀疏矩阵
void CreateMatrixByFile(SMatrix *M)
{
	//创建文件指针，来读取存放在Matrix.txt中的矩阵信息
	FILE *fp = fopen("Matrix.txt","r");
	//判断文件是否存在
	if(fp == NULL) 
		exit(1);
	//读数据：矩阵的行mu，矩阵的列nu
	fscanf(fp,"%d %d",&M->mu, &M->nu);
	
	//读取矩阵内的数据
	int value;  //临时存放读取的值，用来判断读取的值是否为0
	int k = 0; //记录非零元素个数
	for(int i=0; i<M->mu; ++i)
	{
		for(int j=0; j<M->nu; ++j)
		{
			//读取矩阵内的一个元素
			fscanf(fp,"%d",&value);
			if(value != 0)//判断值是不是为0
			{//不为0，将值以三元组的形式存入
				M->data[k].e = value; //值
				M->data[k].i = i;   //所在行
				M->data[k].j = j;   //所在列
				k++; //非零元素个数加一
			}
		}
	}
	M->tu = k; //更改稀疏矩阵中非零元素的个数

	//关闭文件指针
	fclose(fp);
}

通过输入创建稀疏矩阵

//通过输入创建稀疏矩阵
void CreateMatrixByScanf(SMatrix *M)
{

	//读数据：矩阵的行mu，矩阵的列nu
	scanf("%d%d",&M->mu, &M->nu);
	
	//读取矩阵内的数据
	int value;  //临时存放读取的值，用来判断读取的值是否为0
	int k = 0; //记录非零元素个数
	for(int i=0; i<M->mu; ++i)
	{
		for(int j=0; j<M->nu; ++j)
		{
			//读取矩阵内的一个元素
			scanf("%d",&value);
			if(value != 0)//判断值是不是为0
			{//不为0，将值以三元组的形式存入
				M->data[k].e = value; //值
				M->data[k].i = i;   //所在行
				M->data[k].j = j;   //所在列
				k++; //非零元素个数加一
			}
		}
	}
	M->tu = k; //更改稀疏矩阵中非零元素的个数
}

2. 打印矩阵

按矩阵形式打印输出矩阵

//按矩阵形式打印输出矩阵
void PrintMatrix(SMatrix *M)
{
	int **p = NULL;
	int i,j;
	// 申请全部行的首指针
	p = (int **)malloc(M->mu * sizeof(int *)); 
	assert(p != NULL);
	for (i = 0; i < M->mu; i++) 
	{ 
		//申请列的指针
		*(p + i) = (int *)malloc(M->nu *sizeof(int) ); 
		if (*(p + i) == NULL) 
		{ 
			return; 
		} 
 
	} 
	//  初始化数组 
	for (i = 0; i < M->mu; i++) 
	{ 
		for(j = 0; j < M->nu; j++) 
		{ 
			p[i][j] = 0; 
		} 
	} 

	//将非零元素值放入对应位置
	for(i=0; i<M->tu; ++i)
	{
		p[M->data[i].i][M->data[i].j]=M->data[i].e;
	}

	//打印
	//打印稀疏矩阵的总函数和列数
	printf("row=%d, col=%d\n",M->mu,M->nu);
	//打印值
	for (i = 0; i < M->mu; i++) 
	{ 
		for(j = 0; j < M->nu; j++) 
		{ 
			printf("%d\t",p[i][j]);
		} 
		printf("\n");
	} 

}

按三元组形式输出矩阵

//按三元组形式输出稀疏矩阵
void PrintMatrixTriplet(SMatrix *M)
{

	//打印稀疏矩阵的总函数和列数
	printf("row=%d, col=%d\n",M->mu,M->nu);
	//打印三元组中存放的稀疏矩阵中所有非零元素的所在行、所在列以及值
	for(int i=0; i<M->tu; ++i)
	{
		printf("(%d, %d, %d)\n",M->data[i].i,M->data[i].j,M->data[i].e);
	}

}

3. 稀疏矩阵的加法

//稀疏矩阵的加法:M+N=T
void AddMatrix(SMatrix *M, SMatrix *N, SMatrix *T) //M N
{

	//判断M T两个矩阵是否符合加法运算的条件
	if((M->mu!=N->mu)||(M->nu!=N->nu))
		return; //不满足退出

	//满足
	T->mu = M->mu; //加法后的行数
	T->nu = M->nu; //加法后的列数
	int q=0; //用来记录执行矩阵加法后的非零元素个数
	
	int i=0,j=0; 
	
	while((i<M->tu)&&(j<N->tu))
	{
		//将非零元素的二维位置转化为一维，方便比较位置的前后关系
		int lieM=M->data[i].i * M->nu +M->data[i].j;
		int lieN=N->data[j].i * N->nu +N->data[j].j;
		
		if(lieM==lieN)
		{//如果所指向M中的非零元素等于所指向N中的非零元素，则将两者进行相加，相加结果非零就将结果存入T

			int r=M->data[i].e+N->data[j].e; //计算运算的结果
			if(r!=0)//
			{//如果计算结果不为0，则进行存储
				T->data[q].i=M->data[i].i;
				T->data[q].j=M->data[i].j;
				T->data[q].e=r;
				q++;	
			}
			//如果计算结果为0，则不进行存储,直接下移
			i++;
			j++;
		}
		else if(lieM<lieN) 
		{//如果所指向M中的非零元素小于所指向N中的非零元素，则只需要将M中的非零元素存入T
			T->data[q].i=M->data[i].i;
			T->data[q].j=M->data[i].j;
			T->data[q].e=M->data[i].e;
			q++;
			i++;
			
		}
		else if(lieM>lieN)
		{//如果所指向M中的非零元素大于所指向N中的非零元素，则只需要将N中的非零元素存入T
			T->data[q].i=N->data[j].i;
			T->data[q].j=N->data[j].j;
			T->data[q].e=N->data[j].e;
			q++;
			j++;	
		}	
	}
	
	while(i<M->tu)//只剩M中有元素，则将M中剩余的元素加入T
	{
		T->data[q].i=M->data[i].i;
		T->data[q].j=M->data[i].j;
		T->data[q].e=M->data[i].e;
		q++;
		i++;
	}

	while(j<N->tu)//只剩N中有元素，则将N中剩余的元素加入T
	{
		T->data[q].i=N->data[j].i;
		T->data[q].j=N->data[j].j;
		T->data[q].e=N->data[j].e;
		q++;
		j++;
	}
	
	T->tu=q; //修改T中非零元素个数
}

4. 稀疏矩阵的减法

//稀疏矩阵的减法:M-N=T
void SubMatrix(SMatrix *M, SMatrix *N, SMatrix *T)
{

	//判断M T两个矩阵是否符合减法运算的条件
	if((M->mu!=N->mu)||(M->nu!=N->nu))
		return; //不满足退出

	//满足
	T->mu = M->mu; //减法后的行数
	T->nu = M->nu; //减法后的列数
	int q=0; //用来记录执行矩阵减法后的非零元素个数
	
	int i=0,j=0; 
	
	while((i<M->tu)&&(j<N->tu))
	{
		//将非零元素的二维位置转化为一维，方便比较位置的前后关系
		int lieM=M->data[i].i * M->nu +M->data[i].j;
		int lieN=N->data[j].i * N->nu +N->data[j].j;
		
		if(lieM==lieN)
		{//如果所指向M中的非零元素等于所指向N中的非零元素，则将两者进行相减，相加结果非零就将结果存入T

			int r=M->data[i].e-N->data[j].e; //计算运算的结果
			if(r!=0)//
			{//如果计算结果不为0，则进行存储
				T->data[q].i=M->data[i].i;
				T->data[q].j=M->data[i].j;
				T->data[q].e=r;
				q++;	
			}
			//如果计算结果为0，则不进行存储,直接下移
			i++;
			j++;
		}
		else if(lieM<lieN) 
		{//如果所指向M中的非零元素小于所指向N中的非零元素，则只需要将M中的非零元素存入T
			T->data[q].i=M->data[i].i;
			T->data[q].j=M->data[i].j;
			T->data[q].e=M->data[i].e;
			q++;
			i++;
			
		}
		else if(lieM>lieN)
		{//如果所指向M中的非零元素大于所指向N中的非零元素，则只需要将N中的非零元素值的相反数存入T
			T->data[q].i=N->data[j].i;
			T->data[q].j=N->data[j].j;
			T->data[q].e=N->data[j].e*(-1);
			q++;
			j++;	
		}	
	}
	
	while(i<M->tu)//只剩M中有元素，则将M中剩余的元素加入T
	{
		T->data[q].i=M->data[i].i;
		T->data[q].j=M->data[i].j;
		T->data[q].e=M->data[i].e;
		q++;
		i++;
	}

	while(j<N->tu)//只剩N中有元素，则将N中剩余的元素值的相反数加入T
	{
		T->data[q].i=N->data[j].i;
		T->data[q].j=N->data[j].j;
		T->data[q].e=N->data[j].e*(-1);
		q++;
		j++;
	}
	
	T->tu=q; //修改T中非零元素个数
}

5. 稀疏矩阵的乘法

//进行两个稀疏矩阵之间的乘法，返回值为乘积矩阵
 void MulMatrix(SMatrix *M,SMatrix *N,SMatrix *T)
 {
	int p,j,q,i,r,k,t;
	//用于结果的暂存
	int *temp = (int *)malloc(sizeof(int) * N->nu);
	assert(temp != NULL);

	//num[]保存每一行的非零元素个数  rpos[]保存每行元素起始地址
	int *num = (int *)malloc(sizeof(int) * N->mu);
	assert(num != NULL);
	int *rpot = (int*)malloc(sizeof(int) * N->mu);
	assert(rpot != NULL);

	if(M->nu!=N->mu) return ;
	T->mu = M->mu;
	T->nu = N->nu;
	//当M或N中的非零元素为0时
	if(M->tu*N->tu==0)
	{
		T->tu = 0;
		return ;
	}
	//计算N矩阵中每行非0元素的个数
	for(i = 0;i< N->mu;i++)
		num[i] = 0;
	for(i = 0;i<N->tu;i++)
		num[N->data[i].i]++;
	rpot[0] = 0;
	//计算N矩阵中每行首位非0元素的位置
	for(i = 1;i<N->mu;i++)
		rpot[i] = rpot[i-1]+num[i-1];
	r = 0;//记录当前T矩阵中非0元素的个数
	p = 0;//指示当前M矩阵中非零元素的位置
	//进行矩阵的乘积运算
	for(i = 0;i< M->mu;i++)
	{
		//将Tij的累加器初始化
		for(j = 0;j< N->nu;j++)
			temp[j] = 0;
		//求Tij第i行的元素集合
		while(i==M->data[p].i)
		{
			k = M->data[p].j;//获取M矩阵中第p个非零元素的列值
			//确定N中的k行的非零元素在N.data中的下限位置
			if(k<N->mu-1) 
				t = rpot[k+1];
			else 
				t = N->tu;
			//将N中第k行的每一列非零元素与M中非零元素记录到累加器中
			for(q = rpot[k];q<t;q++)
			{
				j = N->data[q].j;
				temp[j] += M->data[p].e*N->data[q].e;
			}
			p++;
		}
		//将第i行的结果赋值给C矩阵
		for(j = 0;j<N->nu;j++)
		{
			if(temp[j]!=0)
			{
				T->data[r].i=i;
				T->data[r].j=j;
				T->data[r].e=temp[j];
				r++;
			}
		}
	}
	T->tu = r;

	//释放空间
	free(temp); 
	free(num); 
	free(rpot);
}

6. 稀疏矩阵的拷贝

//拷贝稀疏矩阵，将M拷贝到T
void CopyMatrix(SMatrix *M, SMatrix *T)
{
	T->mu = M->mu; //拷贝行
	T->nu = M->nu; //拷贝列
	T->tu = M->tu; //拷贝稀疏矩阵非零元素个数

	//将M中每个非零元素以三元组形式拷贝到T
	for(int i=0; i<M->tu; i++)
	{
		T->data[i].i = M->data[i].i; //非零元素所在行
		T->data[i].j = M->data[i].j; //非零元素所在列
		T->data[i].e = M->data[i].e; //非零元素的值
	}
}

7. 稀疏矩阵的转置

一般的转置方法

//稀疏矩阵的转置：将 M 转置存入 T
/*
基本思想：按列优先的形式对 M 中的非零元素进行搜索,
然后将非零元素的所在M中的行列互换之后存入T，此时T的行数
等于M的列数，T的列数等于M的行数。
*/  
void TransposeMatrix(SMatrix *M, SMatrix *T)
{
	T->mu = M->nu;  //将M的列数传给T行数
	T->nu = M->mu;  //将M的行数传给T列数
	T->tu = M->tu;  //将M中的非零元素个数传给T

	int q = 0;//记录转置后的非零元素在T矩阵中的存放位置
	if(M->tu != 0)//判断非零元素个数是否为零
	{//不为0
		//按列优先的形式
		for(int col=0; col<M->nu; ++col)
		{
			//对 M 中的非零元素进行搜索
			for(int p=0; p<M->tu; ++p)
			{
				if(M->data[p].j == col)//如果为第col列的非零元素
				{
					T->data[q].i = M->data[p].j; //将M中col列中的非零元素的列传给T中非零元素的行
					T->data[q].j = M->data[p].i; //将M中col列中的非零元素的行传给T中非零元素的列
					T->data[q].e = M->data[p].e; //将M中col列中的非零元素的值传给T中非零元素的值
					q++;//记录该非零元素在T中的存放位置
				}
			}
		}
	}
}

快速转置

//快速转置
void FastTransposeMatrix(SMatrix *M, SMatrix *T)
{
	T->mu = M->nu;
	T->nu = M->mu;
	T->tu = M->tu;

	//为num向量开辟空间：num[col]表示矩阵M中第col列中非零元的个数
	int *num = (int *)malloc(sizeof(int) * M->nu);//需要的最大空间为M中列的数量个
	assert(num != NULL);
	//为cpot向量开辟空间：cpot[col]指示M中第col列的第一个未转置的非零元素在T->data中的恰当位置
	int *cpot = (int*)malloc(sizeof(int) * M->nu);//需要的最大空间为M中列的数量个
	assert(cpot != NULL);

	//判断非零元素个数是否为零
	if(T->tu != 0)
	{//不为零
		//初始化num向量
		for(int col=0; col<M->nu; ++col)
		{
			num[col] = 0;
		}
		//为num向量赋值
		for(int t=0; t<M->tu; ++t) //搜索M中所有非零元素
		{
			/*
			在搜索M所有非零元素的过程中，遇到相应列的非零元素就让num[col]的值加一，
			其中col指的是对应的列，这样就实现了：对每列非零元素个数的统计并存入num[col]中
			*/
			num[M->data[t].j]++;
		}
		
		/*
			为cpot向量赋值
			此时M中的所有非零元素都还未进行转置，所以此时cpot[col]指示M中
			第col列的第一个非零元素在T->data中的恰当位置
		*/
		cpot[0] = 0;  //第0列的第一个非零元素在T->data中的位置在0下标处
		//为cpot向量剩下的位置赋值
		for(col=1; col<M->nu; ++col)
		{
			//从1列位置开始，cpot[col]的值等于前一列非零元素在T->data中的位置加上前一列非零元素的个数
			cpot[col] = cpot[col-1] + num[col-1];
		}
		
		//利用num向量和cpot向量实现M矩阵的转置（转置结果存放在T矩阵中）
		int q = 0; //用来临时存放提取的cpot[col]的值
		for(int p=0; p<M->tu; ++p)//遍历M中的所有非零元素
		{
			col = M->data[p].j; //获取非零元素的列值
			q = cpot[col];     //由这个列到cpot向量中获取该列第一个未转置的非零元素在T->data中的恰当位置
			//将M中的这个非零元素转置存入T
			T->data[q].i = M->data[p].j; //M中的列--->T中的行
			T->data[q].j = M->data[p].i; //M中的行--->T中的列
			T->data[q].e = M->data[p].e; //M中的值--->T中的值
			/*
			 将第col列的第一个未转置的非零元素在T->data中的位置加一
			（因为原先T中的那个位置已经被插入，下一个转置过来的元素只能存入下一个位置）
			*/
			cpot[col]++; 
		}
	}
	free(num); //释放为num向量的空间
	free(cpot);//释放cpot向量的空间
}

结语

        对矩阵压缩存储的稀疏矩阵的介绍就到这里啦，希望这篇文章能给予你一些帮助，感谢各位人才的：点赞、收藏和评论，我们下次见。

附录

        测试代码：矩阵压缩存储之稀疏矩阵详解（C语言版）

红心火柴
关注
  • 25
    点赞
  • 踩
  • 154
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
数据结构之---C语言实现稀疏矩阵
杨鑫newlife的专栏
05-30 1万+
数据结构之---C语言实现稀疏矩阵
稀疏矩阵的三种存储方式
weixin_30244681的博客
06-15 2785
一，相关概念 ㈠特殊矩阵：矩阵中存在大多数值相同的元,或非0元，且在矩阵中的分布有一定规律。 ⒈对称矩阵：矩阵中的元素满足 aij=aji 1≤i,j≤n ⒉三角矩阵：上（下）三角矩阵指矩阵的下（上）三角（不包括对角线）中的元素均为常数c或0的n阶矩阵。 ⒊对角矩阵（带状矩阵）：矩阵中所有非0元素集中在主对角线为中心的区域中。 ㈡稀...
C语言实现稀疏矩阵
Arithmetic-logic
07-26 3106
稀疏矩阵的压缩存储：对0元不分配 定义结构体（三元组表示法） #define ElemType int typedef struct Triple {//表中每个元素都有3个分量 int i;//行下标 int j;//列下标 ElemType e;//数值 }; typedef struct SMatrix {//用于管理整个矩阵 Triple data[MAXSIZE];//矩阵中的每个元素 int mu;//矩阵的行 int nu;//矩阵的列 int tu;//矩阵的非零个数 };
数据结构进阶(二)矩阵（稀疏矩阵）的压缩存储_稀疏矩阵压缩
最新发布
2401_84411557的博客
05-03 301
（1）按照b.data中三元组的次序依次在a.data中找出相应的三元组进行转置。换句话说，按照矩阵M的列序进行转置。由于a.data是以M的行序为存放每个非零元的，由此得到的恰好是b.data应有的顺序。恰当位置的确定：首先计算M矩阵的每一列（即T的每一行）中非0元的个数，然后求得M矩阵每一列第一个非0元在b.data中的位置。（2）快速转置：按照a.data中三元组的次序进行转置，并将转置后的三元组放到b.data中的恰当位置。（1）按照b矩阵中的行次序依次在a.data中找到相应的三元组进行转置。
(详细)C语言实现-稀疏矩阵及其转置（数据结构）
m0_54158068的博客
05-13 5012
(详细)C语言实现-稀疏矩阵及其转置（数据结构）
数据结构（C/C++）课程阶段总结（八）
遥感在读
06-16 431
写在前面 课程采用教材《数据结构(C语言版)》严蔚敏，吴伟民，清华大学出版社。 本系列博文用于自我学习总结和期末复习使用，同时也希望能够帮助到有需要的同学。如果有知识性的错误，麻烦评论指出。 本次实验实现稀疏矩阵的转置和快速转置。
【C/C++ 数据结构】稀疏矩阵解析：从原理到 C++ 实现 指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-13 1438
稀疏矩阵的存储需要考虑其特性：大部分元素为0或默认值，只有少数元素是非零或非默认值。因此，我们需要一种数据结构，既可以高效地存储这些非零元素，又可以快速地访问它们。
矩阵压缩存储之稀疏矩阵详解（C语言版）.rar
09-20
在IT领域，数据结构是计算机科学的基础之一，它涉及到如何高效地存储和处理数据。本文将深入探讨一种特殊的...了解和掌握稀疏矩阵的压缩存储不仅有助于提高程序效率，还能降低内存消耗，是提升软件性能的关键技能之一。
稀疏矩阵快速转置C语言算法
10-21
数据结构，稀疏矩阵快速转置c语言算法，时间复杂性为O(n+t)。
mtl.rar_MTL_矩阵 模版_矩阵运算 快
09-21
MTL库还提供了高级功能，如稀疏矩阵支持，这对于处理大量零元素的矩阵特别有用。此外，MTL具有良好的内存管理机制，可以有效地处理大矩阵，避免内存溢出问题。同时，MTL还支持动态大小的矩阵，这意味着在程序运行时...
Numpy中对向量、矩阵的使用详解
09-18
在Numpy的scipy子模块中，可以使用`csc_matrix`或`csr_matrix`创建稀疏矩阵： ```python matrix2 = np.array([[0, 0], [0, 1], [3, 0]]) matrix2_sparse = sparse.csc_matrix(matrix2) ``` Numpy提供了丰富的选择...
图之邻接表详解（C语言版）.rar
04-25
相比于邻接矩阵，邻接表在处理稀疏图（边的数量远小于顶点数量的平方）时更加高效，因为它只存储实际存在的边，而邻接矩阵则需要为所有可能的边分配空间。 在C语言中，我们可以使用结构体来定义邻接表。首先，定义...
有关稀疏矩阵(三元数组)的基本操作(C语言)
absorb2601078490的博客
05-28 4047
本文只有代码，介绍了有关栈的基本操作。 已经过调试没有很大问题。 如有错误，还请批评指正。 一、数组的实现和表示：
数据结构——稀疏矩阵（C语言）
明宇逸风的博客
09-17 3637
矩阵什么是矩阵代码实现三元组以及普通转置矩阵以及三元组的结构体相应功能的函数实现初始化稀疏矩阵矩阵转置链表数据的删除按位置查找数据元素合并两个链表输出链表相应功能集成调用主函数运行截图 什么是矩阵 矩阵，简单的来看，就是二维数组。二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。 代码实现 三元组以及普通转置 矩阵以及三元组的结构体 #include<stdio.h> #include&
数据结构-稀疏矩阵的乘法（C语言）
lzxgua777的博客
03-30 1494
由图可知，M和转置后的T都是按顺序排列的，我们应该从M中找出列为1(也就是在T中行为1)的元素，由于是顺序表，我们不用担心T中同一行列数的顺序，每找到一个，它就是T中的一个元素，并且M.data[i].i=T.data[cnt].j;在做矩阵乘法时，我们遍历到了M和T中的每一个元素，当M中元素的列数和T中元素的行数相同时，他们就可以相乘，此时Q矩阵的行数等于M矩阵的行数，Q矩阵的列数等于T矩阵的列数，Q矩阵的值等于M和T的值的乘积。对于M矩阵每一列在T矩阵对应行的乘积运算应该是累加的！
稀疏矩阵的乘法运算（C语言）
2301_79497461的博客
11-20 402
数据压缩是提高传输、存储效率一种技术。教材第5章介绍了两种简单的压缩存储方法。 本实验要求实现两个稀疏矩阵相乘积的算法。其中稀疏矩阵非零元素数量小于100.
C语言数据结构之稀疏矩阵（一）
long1175727752的博客
01-07 7324
最近开始学习C语言的稀疏矩阵的一些知识，现在简单的整理梳理一下知识脉络，仅供自己总结学习，欢迎技术指正，拒绝盲喷。 1.首先先介绍一下关于稀疏矩阵的一些基础知识，关于稀疏矩阵，一直都没有过很清楚详细的定义。简单的说，在M*N的一个矩阵中，假设有t个元素不为0，那么有计算公式：δ=t/(m*n).称δ为该矩阵的稀疏因子，一般认为当δ(并无具体规定)的时候称该矩阵为稀疏矩阵。 2.
稀疏矩阵的压缩储存，稀疏矩阵的普通转置，稀疏矩阵的快速转置
04-18 1187
前言：什么是稀疏矩阵： 一个M*N（即M行N列）的矩阵，矩阵中有效值的个数远小于无效值的个数，且这些数据的分布没有规律。 例如：一个6行5列的稀疏矩阵(M = 6，N = 5) 1, 0, 3, 0, 5 0, 0, 0, 0, 0 0, 0, 0, 0, 0 1, 0, 3, 0, 5 0, 0, 0, 0, 0 0, 0, 0, 0, 0 一、稀疏矩阵的压缩储存
c语言稀疏矩阵_C中的稀疏矩阵
culing2941的博客
09-17 1303
c语言稀疏矩阵In this tutorial, we are going to learn about the sparse matrix in C. 在本教程中，我们将学习C语言中的稀疏矩阵。 Before we start let us first discuss what a little bit about two-dimensional arrays. A matrix is r...
稀疏矩阵压缩存储c++思路
09-10
稀疏矩阵压缩存储是一种优化矩阵存储空间的方式。当矩阵中大部分元素为0或者重复元素较多时，采用传统的二维数组存储方式会导致存储空间的浪费，因此采用稀疏矩阵压缩存储可以节省存储空间。 稀疏矩阵压缩存储的思路是将稀疏矩阵中的非零元素按照行优先的原则逐个存储起来，同时还需要记录每个非零元素的行号、列号以及其对应的值。压缩存储后的矩阵可以表示为一个线性数组，数组的每个元素都包含三个部分：行号、列号和元素值。这样可以避免存储大量的0元素，从而减少存储空间的开销。 在进行矩阵的压缩存储时，可以采用稀疏矩阵的三元组存储方法，即将非零元素的行号、列号和值分别存储在三个单独的一维数组中。实际应用中，还可以基于三元组存储方法的基础上进行进一步的优化，例如使用链表结构来存储非零元素，以减少内存的消耗。 此外，在稀疏矩阵压缩存储过程中，还需要考虑到数据的读取和修改操作。读取非零元素时，可以直接通过行号和列号索引到相应的元素，而修改非零元素时，需要先找到对应的索引再进行修改。 总体来说，稀疏矩阵压缩存储是通过将稀疏矩阵中的非零元素存储起来，避免存储大量的0元素，从而减少存储空间的开销。具体的实现方法可以采用稀疏矩阵的三元组存储方法或其他优化方式，以提高存储效率和减少内存消耗。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值