稀疏矩阵的三元组表示（ANSI C）

最新推荐文章于 2023-09-01 19:49:26 发布
最新推荐文章于 2023-09-01 19:49:26 发布
阅读量580 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c dst fp null file struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkcoder/article/details/7627159
版权

1、基本结构定义

typedef int elem_type;

typedef struct triplet
{
	int r, c;
	elem_type elem;
}triplet;

typedef struct sparse_mat
{
	triplet * data;
	int rows;
	int cols;
	int n_elem;
}sparse_mat;
2、从数据文件初始化、释放 
void init_sparse_mat( sparse_mat * mat, const char * file )
{
	FILE * fp = fopen( file, "r+" );
	int rows, cols, n_elem = 0;
	int i, j, k = 0;
	elem_type e;
	assert( fp != NULL );
	fscanf( fp, "%d %d", &rows, &cols );
	mat->rows = rows;
	mat->cols = cols;
	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			fscanf( fp, "%d", &e );
			if( e != 0 )
				++n_elem;
		}
	}
	mat->n_elem = n_elem;

	//rewind( fp );
	fseek( fp, 2 * sizeof( int ), SEEK_SET );

	mat->data = ( triplet * )malloc( sizeof( triplet ) * n_elem );
	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			fscanf( fp, "%d", &e );
			if( e != 0 )
			{
				mat->data[k].r = i;
				mat->data[k].c = j;
				mat->data[k].elem = e;
				++k;
			}
		}
	}
	fclose( fp );
}

void free_sparse_mat( sparse_mat * mat )
{
	if( mat->data != NULL )
		free( mat->data );
	mat->rows = mat->cols = mat->n_elem = 0;
}
3、矩阵转置 
void transpose_sparse_mat( sparse_mat * src, sparse_mat * dst )
{
	int i, j, k = 0;
	dst->rows = src->cols;
	dst->cols = src->rows;
	dst->n_elem = src->n_elem;
	dst->data = ( triplet * )malloc( sizeof( triplet ) * dst->n_elem );

	if( dst->n_elem > 0 )
	{
		for( i = 0; i < src->cols; ++i )
		{
			for( j = 0; j < src->n_elem; ++j )
			{
				if( i == src->data[j].c )
				{
					dst->data[k].r = src->data[j].c;
					dst->data[k].c = src->data[j].r;
					dst->data[k].elem = src->data[j].elem;
					++k;
				}
			}
		}
	}
}
4、快速转置 

void fast_transpose( sparse_mat * src, sparse_mat * dst )
{
	int * ins_pos = NULL, * n_elem = NULL;
	int rows = src->rows, cols = src->cols;
	int i, j;
	dst->rows = cols;
	dst->cols = rows;
	dst->n_elem = src->n_elem;
	if( dst->data != NULL )
		free( dst->data );
	dst->data = ( triplet * )malloc( sizeof( triplet ) * dst->n_elem );
	
	ins_pos = ( int * )malloc( sizeof( int ) * rows );
	n_elem = ( int * )malloc( sizeof( int ) * cols );
	memset( ins_pos, 0, sizeof( int ) * cols );
	memset( n_elem, 0, sizeof( int ) * cols );

	/* first round of scanning */
	for( i = 0; i < src->n_elem; ++i )
	{
		++n_elem[src->data[i].c];
	}

	ins_pos[0] = 0;
	for( i = 1; i < src->cols; ++i )
	{
		ins_pos[i] = ins_pos[i - 1] + n_elem[i - 1];
	}

	/* second round of scanning */
	for( i = 0; i < src->n_elem; ++i )
	{
		j = ins_pos[src->data[i].c]++;
		dst->data[j].elem = src->data[i].elem;
		dst->data[j].r = src->data[i].c;
		dst->data[j].c = src->data[i].r;
	}
}
5、矩阵的输出 

void disp_sparse_mat( sparse_mat * mat )
{
	elem_type ** data = NULL;
	int rows, cols, i, j;
	int r, c;
	rows = mat->rows;
	cols = mat->cols;

	data = ( elem_type ** )malloc( sizeof( elem_type * ) * rows );
	for( i = 0; i < rows; ++i )
	{
		data[i] = ( elem_type * )malloc( sizeof( elem_type ) * cols );
		memset( data[i], 0, cols * sizeof( elem_type ) );
	}

	for( i = 0; i < mat->n_elem; ++i )
	{
		r = mat->data[i].r;
		c = mat->data[i].c;
		data[r][c] = mat->data[i].elem;
	}

	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			printf( "%d ", data[i][j] );
		}
		printf( "\n" );
	}
}

6、完整程序

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef int elem_type;

typedef struct triplet
{
	int r, c;
	elem_type elem;
}triplet;

typedef struct sparse_mat
{
	triplet * data;
	int rows;
	int cols;
	int n_elem;
}sparse_mat;


void init_sparse_mat( sparse_mat * mat, const char * file )
{
	FILE * fp = fopen( file, "r+" );
	int rows, cols, n_elem = 0;
	int i, j, k = 0;
	elem_type e;
	assert( fp != NULL );
	fscanf( fp, "%d %d", &rows, &cols );
	mat->rows = rows;
	mat->cols = cols;
	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			fscanf( fp, "%d", &e );
			if( e != 0 )
				++n_elem;
		}
	}
	mat->n_elem = n_elem;

	//rewind( fp );
	fseek( fp, 2 * sizeof( int ), SEEK_SET );

	mat->data = ( triplet * )malloc( sizeof( triplet ) * n_elem );
	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			fscanf( fp, "%d", &e );
			if( e != 0 )
			{
				mat->data[k].r = i;
				mat->data[k].c = j;
				mat->data[k].elem = e;
				++k;
			}
		}
	}
	fclose( fp );
}

void free_sparse_mat( sparse_mat * mat )
{
	if( mat->data != NULL )
		free( mat->data );
	mat->rows = mat->cols = mat->n_elem = 0;
}

void disp_sparse_mat( sparse_mat * mat )
{
	elem_type ** data = NULL;
	int rows, cols, i, j;
	int r, c;
	rows = mat->rows;
	cols = mat->cols;

	data = ( elem_type ** )malloc( sizeof( elem_type * ) * rows );
	for( i = 0; i < rows; ++i )
	{
		data[i] = ( elem_type * )malloc( sizeof( elem_type ) * cols );
		memset( data[i], 0, cols * sizeof( elem_type ) );
	}

	for( i = 0; i < mat->n_elem; ++i )
	{
		r = mat->data[i].r;
		c = mat->data[i].c;
		data[r][c] = mat->data[i].elem;
	}

	for( i = 0; i < rows; ++i )
	{
		for( j = 0; j < cols; ++j )
		{
			printf( "%d ", data[i][j] );
		}
		printf( "\n" );
	}
}

void transpose_sparse_mat( sparse_mat * src, sparse_mat * dst )
{
	int i, j, k = 0;
	dst->rows = src->cols;
	dst->cols = src->rows;
	dst->n_elem = src->n_elem;
	dst->data = ( triplet * )malloc( sizeof( triplet ) * dst->n_elem );

	if( dst->n_elem > 0 )
	{
		for( i = 0; i < src->cols; ++i )
		{
			for( j = 0; j < src->n_elem; ++j )
			{
				if( i == src->data[j].c )
				{
					dst->data[k].r = src->data[j].c;
					dst->data[k].c = src->data[j].r;
					dst->data[k].elem = src->data[j].elem;
					++k;
				}
			}
		}
	}
}

void fast_transpose( sparse_mat * src, sparse_mat * dst )
{
	int * ins_pos = NULL, * n_elem = NULL;
	int rows = src->rows, cols = src->cols;
	int i, j;
	dst->rows = cols;
	dst->cols = rows;
	dst->n_elem = src->n_elem;
	if( dst->data != NULL )
		free( dst->data );
	dst->data = ( triplet * )malloc( sizeof( triplet ) * dst->n_elem );
	
	ins_pos = ( int * )malloc( sizeof( int ) * rows );
	n_elem = ( int * )malloc( sizeof( int ) * cols );
	memset( ins_pos, 0, sizeof( int ) * cols );
	memset( n_elem, 0, sizeof( int ) * cols );

	/* first round of scanning */
	for( i = 0; i < src->n_elem; ++i )
	{
		++n_elem[src->data[i].c];
	}

	ins_pos[0] = 0;
	for( i = 1; i < src->cols; ++i )
	{
		ins_pos[i] = ins_pos[i - 1] + n_elem[i - 1];
	}

	/* second round of scanning */
	for( i = 0; i < src->n_elem; ++i )
	{
		j = ins_pos[src->data[i].c]++;
		dst->data[j].elem = src->data[i].elem;
		dst->data[j].r = src->data[i].c;
		dst->data[j].c = src->data[i].r;
	}
}

int main( int argc, char * argv[] )
{
	char file[] = "data.txt";
	sparse_mat src, dst, dst2;

	dst.data = dst2.data = NULL;

	init_sparse_mat( &src, file );
	disp_sparse_mat( &src );

	printf( "------ general transpose -------\n" );
	transpose_sparse_mat( &src, &dst );
	disp_sparse_mat( &dst );

	printf( "------- fast transpose ---------\n" );
	fast_transpose( &src, &dst2 );
	disp_sparse_mat( &dst2 );

	free_sparse_mat( &src );
	free_sparse_mat( &dst );
	free_sparse_mat( &dst2 );
}
7、数据文件格式 
5 6
0 0 0 0 0 0
1 0 0 0 2 0
0 0 0 3 0 0
4 0 5 0 0 6
0 0 0 0 7 0

zkcoder
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（三十）第 5 章 数组和广义表（稀疏矩阵的三元组顺序表）
墨夜白
10-12 217
算法 5.1 ~ 5.2
（三十一）第 5 章 数组和广义表（稀疏矩阵的三元组行逻辑链接的顺序存储）
最新发布
墨夜白
04-29 53
算法 5.3
稀疏矩阵的三元组表示
08-03
数据结构 稀疏矩阵的三元组表示 VC6.0下调试通过。要用功~Copy代码是不行的！
Eigen 3.2稀疏矩阵入门
chengde6896383的专栏
12-12 4965
https://my.oschina.net/cvnote/blog/166980 Eigen自带的稀疏矩阵分解功能包括LDLt、LLt分解（即Cholesky分解，这个功能是LGPL许可，不是Eigen的MPL许可）、LU分解、QR分解（这个是3.2版本之后正式Release的）、共轭梯度解矩阵等。另外还提供了到第三方稀疏矩阵库的C++接口，包括著名的SuiteSparse系列（这个系列非常强...
C语言 稀疏矩阵操作（三元组表示法）
热门推荐
思考的力量
12-12 2万+
//稀疏矩阵实例 //作者：nuaazdh //时间：2011年12月11日 12:15:38 #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 typedef int Status; typedef float ElemType;
C语言专插本知识点
Teleicyq的博客
11-09 6852
1程序结构 顺序结构、选择结构(分支结构)、循环结构 2.位 字节 bit是位 是指为0或者1，byte是指字节，一个字节 = 八个位 3.基础认识 c语言编写的程序称为源程序，又称为编译单位 只有一个main函数，是程序运行的起点 4.标识符 关键词不能作为标识符号 预定义标识符：define scanf printf include 可以做为用户标识符 5.进制转换 十进制转换成二、八、十六进制 二、八、十六进制转换成十进制 C语言只有八、是、十六进制，没有二进制 ！！！
计算机基础与程序设计
Teleicyq的博客
04-13 6697
1程序结构 顺序结构、选择结构(分支结构)、循环结构 2.位 字节 bit是位 是指为0或者1，byte是指字节，一个字节 = 八个位 3.基础认识 c语言编写的程序称为源程序，又称为编译单位 只有一个main函数，是程序运行的起点 4.标识符 关键词不能作为标识符号 预定义标识符：define scanf printf include 可以做为用户标识符 5.进制转换 十进制转换成二、八、十六进制 二、八、十六进制转换成十进制 C语言只有八、是、十六进制，没有二进制 ！！！
稀疏矩阵 c++ 三元组表
05-03
三元组表是最简单的稀疏矩阵存储方式，它将矩阵中的每个非零元素用一个三元组表示，包括行索引、列索引和对应的值。例如，一个5×5矩阵中的元素(2,3)=4将被表示为(2, 3, 4)。所有三元组按行优先或列优先顺序存储，...
已知稀疏矩阵用三元组表示编写C=A*B的算法。
05-14
已知稀疏矩阵用三元组表示编写C=A*B的算法。
数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现最新文档.doc
12-01
数据结构 C 语言版-稀疏矩阵的三元组顺序表存储表示和实现最新文档 本文档介绍了稀疏矩阵的三元组顺序表存储表示和实现的相关知识点。 1. 稀疏矩阵的定义： 稀疏矩阵是一种特殊的矩阵，在矩阵中只有少数元素为非...
17.稀疏矩阵和三元组稀疏矩阵压缩算法.ppt
03-02
17.稀疏矩阵和三元组稀疏矩阵压缩算法.ppt
数据结构与算法
cookieeee_的博客
09-01 194
只用于学习、预习、复习个人使用，其他用途均需本人同意（摘录于课堂课件，懒猫老师）
【数据结构】--稀疏矩阵的三元组表示方式
weixin_44367884的博客
12-10 1912
//矩阵的三元组表示方式; #include<stdio.h> #define number 3//假设非零元的行下标的最大值为3; typedef struct { int i,j; int data; }triple; typedef struct { triple data[number];//非零元三元组表，data[0]未用; int...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8830
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3279
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3730
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
稀疏矩阵三元组转置代码C语言
11-10
以下是稀疏矩阵三元组转置的C语言代码：\n\```\#inclu <stdi.h>\#defi MAXSIZE 12500\n\ypedef stru {\ i i, j;\ i ;\} Trip;\n\ypedef stru {\ Trip [MAXSIZE + 1];\ i mu, nu, tu;\} TSMatrix;\n\voi ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值