稀疏矩阵的实现

最新推荐文章于 2021-06-20 23:18:45 发布
最新推荐文章于 2021-06-20 23:18:45 发布
阅读量675 收藏 3
点赞数 1
分类专栏： 数据结构 linux 算法 文章标签： c data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perry0528/article/details/82356820
版权
数据结构 同时被 3 个专栏收录
29 篇文章 5 订阅
订阅专栏
算法
27 篇文章 1 订阅
订阅专栏
linux
3 篇文章 0 订阅
订阅专栏
  • 主要实现的难点在于稀疏矩阵的转置以及矩阵乘法。
  • 对用到的数据结构定义不懂的可参考严蔚敏老师的数据结构书籍，这里讲严老师讲的两种数据结构三元组结构 和行逻辑结构 整合到一起。
  • 稀疏矩阵是线性结构中比较难的一块知识点，不懂的建议去b站看看严老师的视频。
  • 实现环境：linux
数据结构
typedef struct {
	int i, j; //行坐标，列坐标
	Elem e; //元素值
}Triple;//三元组（i,j,e）

typedef struct {
	Triple data[MAXSIZE]; 
	int rpos[MAXRC];
	int *num;
	int *cpot;
	int mu, nu, tu; //总行数，总列数，非零元素总数
}Matrix;
  1. 其中rpos表示每行第一个元素在data中的位置
  2. num表示每一列元素的个数
  3. cpot表示每一列第一个元素在转置矩阵中应处的位置

Matrix.h

#ifndef MATRIX_H_
#define MATRIX_H_

#include <stdbool.h>
#define MAXSIZE 12500
#define MAXRC 500

typedef int Elem;

typedef struct {
	int i, j;
	Elem e;
}Triple;

typedef struct {
	Triple data[MAXSIZE];
	int rpos[MAXRC];
	int *num;
	int *cpot;
	int mu, nu, tu;
}Matrix;


/*create a matrix*/
void CreateMatrix(Matrix *M);

/*destroy the matrix*/
void DestroyMatrix(Matrix *M);

/*print the matrix*/
void PrintMatrix(Matrix M);

/*return the matrix transpose of a given matrix*/
bool TransposeMatrix(Matrix M, Matrix *T);

/*take the product of the sparse matrix Q=M*N*/
bool MultiMatrix(Matrix M, Matrix N, Matrix *T);

#endif

Matrix.c

#include "Matrix.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*create a matrix*/
void CreateMatrix(Matrix *M) {
	int m, n, t;
	
	scanf("%d%d%d", &m, &n, &t);
	//scanf("%d", &n);
	//scanf("%d", &t);
	M->mu = m;
	M->nu = n;
	M->tu = t;
	//printf("%d\n", M->tu);
	Triple T;
	bool k;
	int i;
	scanf("%d%d%d", &T.i, &T.j, &T.e);
	do {
		k = 0;
		if (T.i < 1 || T.i > M->mu || T.j < 1 || T.j > M->nu) {
			k = 1;
			printf("wrong input !\nplease enter again! \n");
			scanf("%d%d%d", &T.i, &T.j, &T.e);
		}
	}while(k);
	M->data[0] = T;
//	printf("%d\n",M->data[0].i);
	for (i = 1; i < M->tu; i++) {
		scanf("%d%d%d", &T.i, &T.j, &T.e);
	        do {
        	        k = 0;
               		if (T.i < 1 || T.i > M->mu || T.j < 1 || T.j > M->nu || T.i < M->data[i-1].i || (T.i == M->data[i-1].i && T.j <= M->data[i-1].j)) {
                        	k = 1;
                       		printf("wrong input !\nplease enter again! \n");
                        	scanf("%d%d%d", &T.i, &T.j, &T.e);
                	}
        	}while(k);
        	M->data[i] = T;

	}
	M->num = (int*)malloc(M->nu*sizeof(int));
	M->cpot = (int*)malloc(M->nu*sizeof(int));
	memset(M->num, 0x0, M->nu*sizeof(int));
	memset(M->cpot, 0x0, M->nu*sizeof(int));
	for (i = 0; i < M->tu; i++) {
		M->num[M->data[i].j - 1]++;	
	}
	M->cpot[0] = 1;
	for (i = 1; i < M->nu; i++) {
		M->cpot[i] = M->cpot[i-1] + M->num[i-1];	
	}
	M->rpos[0] = 1;
	int Num[M->mu];
	memset(Num, 0x0, M->mu*sizeof(int));
	for(i = 0; i < M->tu; i++) {
		Num[M->data[i].i-1]++;
	}
	/*for(i = 1 ; i < M->mu ; i++) {
                printf("%d\n",Num[i-1]);
        }*/
	
	for(i = 1 ; i < M->mu ; i++) {
		M->rpos[i] = M->rpos[i-1] + Num[i-1];
	}
	/*for (i = 1; i < M->tu; i++) {
		if (M->data[i].i > M->data[i-1].i) {
			M->rpos[M->data[i].i-1] = i + 1;
		}
	}*/
	/*for (i = 1; i < M->tu; i++) {
		if (M->data[i].i > M->data[i-1].i+1) {
			int m = M->data[i].i - M->data[i-1].i;
			for (int a = M->data[i-1].i + 1; a < M->data[i].i; i++) {
				M->rpos[a-1] = M->rpos[M->data[i-1].i-1];
			}
		}
	}*/
}

/*destroy the matrix*/
void DestroyMatrix(Matrix *M) {
	M->mu = 0;
	M->tu = 0;
	M->nu = 0;
	free(M->num);
	free(M->cpot);			
}

/*print the matrix*/
void PrintMatrix(Matrix M) {
	int i;
 
	printf("%d行%d列%d个非零元素。\n",M.mu,M.nu,M.tu);
 
   	printf("行  列  元素值\n");
 
   	for(i=0;i<M.tu;i++)
 
     		printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);
 
   	for(i=1;i<=M.mu;i++)
 
     		printf("第%d行的第一个非零元素是本矩阵第%d个元素\n",i,M.rpos[i-1]);
	for(i=1;i<=M.nu;i++)
		printf("第%d列的元素个数为%d\n",i,M.num[i-1]);
	for(i=1;i<=M.nu;i++)
		printf("第%d列的第一个元素的位置是%d\n",i,M.cpot[i-1]);	
}

/*return the matrix transpose of a given matrix*/
bool TransposeMatrix(Matrix M, Matrix *T) {
	Matrix A;
	A = M;
	T->nu = A.mu;
	T->mu = A.nu;
	T->tu = A.tu;
	for (int i = 0; i < T->tu; i++) {
		T->data[A.cpot[A.data[i].j-1]-1].i = A.data[i].j;
		T->data[A.cpot[A.data[i].j-1]-1].j = A.data[i].i;
		T->data[A.cpot[A.data[i].j-1]-1].e = A.data[i].e;
		A.cpot[A.data[i].j-1]++;	
	}
	T->num = (int*)malloc(T->nu*sizeof(int));
        T->cpot = (int*)malloc(T->nu*sizeof(int));
        memset(T->num, 0x0, T->nu*sizeof(int));
        memset(T->cpot, 0x0, T->nu*sizeof(int));
	int i = 0;
        for (i = 0; i < T->tu; i++) {
                T->num[T->data[i].j - 1]++;
        }
        T->cpot[0] = 1;
        for (i = 1; i < T->nu; i++) {
                T->cpot[i] = T->cpot[i-1] + T->num[i-1];
        }
        T->rpos[0] = 1;
        int Num[T->mu];
        memset(Num, 0x0, T->mu*sizeof(int));
        for(i = 0; i < T->tu; i++) {
                Num[T->data[i].i-1]++;
        }

}

/*take the product of the sparse matrix Q=M*N*/
bool MultiMatrix(Matrix M, Matrix N, Matrix *T) {
	if (M.nu != N.mu)
		return 0;
	T->mu = M.mu;
	T->nu = N.nu;
	T->tu = 0;
	if (M.tu*N.tu != 0)
		for (int arow = 1; arow <= M.mu; arow++) {	
			int ctemp[N.nu];
			memset(ctemp, 0x0, N.nu*sizeof(int));
			T->rpos[arow-1] = T->tu+1;
			int tp = 0;
			if(arow < M.mu)
				tp = M.rpos[arow];
			else
				tp = M.tu + 1;
			for (int p = M.rpos[arow-1]; p < tp; p++) {
				int t = M.data[p-1].j;
				int pause;
				if (t < N.mu)
					pause = N.rpos[t];
				else
					pause = N.tu + 1;
				for (int m = N.rpos[t-1]; m < pause; m++) {
					ctemp[N.data[m-1].j-1] += M.data[p-1].e*N.data[m-1].e;
				}
			}
			for (int i = 0; i < N.nu; i++) {
				if (ctemp[i] != 0) {
					T->data[T->tu].i = arow;
					T->data[T->tu].j = i + 1;
					T->data[T->tu].e = ctemp[i];
					T->tu++;
				}
			}
		}
	T->num = (int*)malloc(T->nu*sizeof(int));
        T->cpot = (int*)malloc(T->nu*sizeof(int));
        memset(T->num, 0x0, T->nu*sizeof(int));
        memset(T->cpot, 0x0, T->nu*sizeof(int));
        for (int i = 0; i < T->tu; i++) {
                T->num[T->data[i].j - 1]++;
        }
        T->cpot[0] = 1;
        for (int i = 1; i < T->nu; i++) {
                T->cpot[i] = T->cpot[i-1] + T->num[i-1];
        }

	return 1;
}

main.c

#include <stdio.h>
#include "Matrix.h"
int main () {
	Matrix M;
	Matrix N;
	Matrix A;	
	CreateMatrix(&M);
	CreateMatrix(&N);
	PrintMatrix(M);
	PrintMatrix(N);
	TransposeMatrix(M,&A);
	PrintMatrix(A);
	Matrix T;
	MultiMatrix(M,N,&T);
	PrintMatrix(T);
	DestroyMatrix(&A);
	DestroyMatrix(&T);
	DestroyMatrix(&M);
	DestroyMatrix(&N);
	return 0;
}

makefile

object = main.o Matrix.o

test : $(object)
	gcc -g -Wall -o test $(object)

main.o : Matrix.h
Matrix.o : Matrix.h

.PHONY:clean
clean:
	rm -rf *.o

运行检查：

用于测试的矩阵：

(a) M = [ 3 0 0 5 0 − 1 0 0 2 0 0 0 ] {M=} \left[ \begin{matrix} 3 &amp; 0 &amp; 0 &amp; 5\\ 0&amp;-1 &amp; 0 &amp; 0 \\ 2 &amp; 0 &amp; 0 &amp; 0 \end{matrix} \right] \tag{a} M=⎣⎡​302​0−10​000​500​⎦⎤​(a)
(b) N = [ 0 2 1 0 − 2 4 0 0 ] {N=} \left[ \begin{matrix} 0 &amp; 2 \\ 1 &amp; 0 \\ -2 &amp; 4 \\ 0 &amp; 0 \end{matrix} \right] \tag{b} N=⎣⎢⎢⎡​01−20​2040​⎦⎥⎥⎤​(b)

M.data
ije
113
145
22-1
312
N.data
ije
122
211
31-2
324
M*N结果：
ije
126
21-1
324
输入文件input.txt
3 4 4
1 1 3
1 4 5
2 2 -1
3 1 2
4 2 4
1 2 2
2 1 1
3 1 -2
3 2 4
输出文件test.txt
3行4列4个非零元素。
行  列  元素值
 1   1       3
 1   4       5
 2   2      -1
 3   1       2
第1行的第一个非零元素是本矩阵第1个元素
第2行的第一个非零元素是本矩阵第3个元素
第3行的第一个非零元素是本矩阵第4个元素
第1列的元素个数为2
第2列的元素个数为1
第3列的元素个数为0
第4列的元素个数为1
第1列的第一个元素的位置是1
第2列的第一个元素的位置是3
第3列的第一个元素的位置是4
第4列的第一个元素的位置是4
4行2列4个非零元素。
行  列  元素值
 1   2       2
 2   1       1
 3   1      -2
 3   2       4
第1行的第一个非零元素是本矩阵第1个元素
第2行的第一个非零元素是本矩阵第2个元素
第3行的第一个非零元素是本矩阵第3个元素
第4行的第一个非零元素是本矩阵第5个元素
第1列的元素个数为2
第2列的元素个数为2
第1列的第一个元素的位置是1
第2列的第一个元素的位置是3
4行3列4个非零元素。
行  列  元素值
 1   1       3
 1   3       2
 2   2      -1
 4   1       5
第1行的第一个非零元素是本矩阵第1个元素
第2行的第一个非零元素是本矩阵第0个元素
第3行的第一个非零元素是本矩阵第0个元素
第4行的第一个非零元素是本矩阵第0个元素
第1列的元素个数为2
第2列的元素个数为1
第3列的元素个数为1
第1列的第一个元素的位置是1
第2列的第一个元素的位置是3
第3列的第一个元素的位置是4
3行2列3个非零元素。
行  列  元素值
 1   2       6
 2   1      -1
 3   2       4
第1行的第一个非零元素是本矩阵第1个元素
第2行的第一个非零元素是本矩阵第2个元素
第3行的第一个非零元素是本矩阵第3个元素
第1列的元素个数为1
第2列的元素个数为2
第1列的第一个元素的位置是1
第2列的第一个元素的位置是2
linux运行程序确实舒服，直接命令行就可以读取文本
make
#运行makefile
./test < input.txt > test.txt
#运行生成的可执行文件test
make clean
#清理.o文件
perry0528
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现稀疏矩阵的相加运算
03-21
实现了稀疏矩阵A+B相加 数据结构中的采用结构体数组进行稀疏矩阵的存储
一种稀疏矩阵的实现方法
tkokof1的专栏
09-29 960
本文简单描述了一种稀疏矩阵的实现方式,并与一般矩阵的实现方式做了性能和空间上的对比 矩阵一般以二维数组的方式实现,代码来看大概是这个样子: // C# public class Matrix { // methods // elements ElementType[,] m_elementBuffer; } 实现方式简单直观,但是对于稀疏矩阵而言,空间上的浪费比较严...
稀疏矩阵及其实现
吾人为学
11-10 446
稀疏矩阵及其实现 这一节用到了数组的一些知识，和线代中矩阵的计算方法。建议没有基础的读者去看一下矩阵的相关知识。 和之前的博客一样，这次依然参考了严蔚敏的《数据结构（C语言版）》。 稀疏矩阵的预定义/*--------稀疏矩阵的三元组顺序表存储表示----------*/ typedef int ElemType;#define MAXSIZE 12500 // 假设非零元个数的最大数值
Ptyhon 实现稀疏矩阵
qq_43826983的博客
12-02 188
稀疏矩阵（Sparse Matirx）:一个矩阵的大部分元素为零 对于稀疏矩阵而言，实际存储的数据项很少，如果用传统的二维数组的方式来存储稀疏矩阵，会十分浪费计算机的内存空间。 C=[[None]*N for row in range(N)] 提高内存空间利用率的方法就是利用三项式（3-tuple)的数据结构，把每一个非零项以（i,j,item-value）来表示。 就是假如一个稀疏矩阵有n个...
数据结构与算法-稀疏矩阵（三元表的实现）
kwenzh的博客
05-02 7068
        稀疏矩阵，矩阵中非零元素的个数远小于矩阵元素总数，且非零元素的分布没有规律，可以称该矩阵为稀疏矩阵。如果还用一个row*col的矩阵去表示这些信息，浪费空间，可以对矩阵换一种存储结构，只需要记录矩阵中非零元素的位置和值。也就是通过三元表来完成一个稀疏矩阵的表示，此外还有通过链表，这里讲一下三元表的稀疏矩阵以及稀疏矩阵的打印，转置。               三元表的结构就是下图，...
稀疏矩阵实现和快速转置（C++）
05-14
C++实现稀疏矩阵创建、快速转置（数据结构），含有具体的代码注释说明，条理清晰。
C语言实现稀疏矩阵
01-01
本文实例为大家分享了C语言实现稀疏矩阵的具体代码，供大家参考，具体内容如下 #include stdio.h #define maxsize 10 typedef struct { int i,j; //非零元素的行、列 int v; //非零元素的值 }Triple; typedef ...
Java实现 稀疏矩阵乘积
12-22
稀疏矩阵乘积 描述 给定两个N × N的稀疏矩阵A和B，其中矩阵A有P个元素非0，矩阵B有Q个元素非0。请计算两个矩阵的乘积C = A × B并且输出C中所有非0的元素。 输入 第一行包含三个整数N, P, Q 以下P行每行三个整数i, ...
C++ 实现稀疏矩阵的压缩存储的实例
08-29
主要介绍了C++ 实现稀疏矩阵的压缩存储的实例的相关资料,M*N的矩阵，矩阵中有效值的个数远小于无效值的个数，且这些数据的分布没有规律，需要的朋友可以参考下
稀疏矩阵介绍及实现
xiaoshiguang3的博客
06-08 3706
稀疏矩阵 1、基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 2、稀疏数组的处理方法 1）记录数组一共有几行几列，有多少个不同的值(假设有sum个，则稀疏矩阵有sum+1行，3列) 2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 3、举例说明 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZLXHkQe4-1591629865757)(en-resource://database/525:1)] 4、
稀疏矩阵
happy___wind的博客
05-16 1099
稀疏矩阵（sparse matrix）是矩阵的一种特殊情况，其非零元素的个数远远小于零元素的个数，且分布没有规律。 设一个m行n列的矩阵有t个非零元素，则系数因子δ为：           通常当δ          0   0   2     0    0     0   0          3   0   0   -11   0      0   0 A=    0    0  
01 数据结构与算法之稀疏矩阵的处理及代码实现
朱古力的博客
05-10 566
稀疏矩阵 1. 基本介绍 稀疏矩阵：数组存放很多没有意义的数据。 稀疏数组的处理方法： （1）记录数组一共有几行几列，有多少个不同的值。 （2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。 2. 思路分析 遍历原始的稀疏矩阵，得到有效的数据的个数 sum。 根据 sum 就可以创建新数组 newArray[sum + 1][3]。 新数组的第一行存储稀疏数组的行数、列数、有效数个数。 之后的每一行存储有效数据的行数、列数、该有效数。 [外链图片转存失败,源站
数据结构 稀疏矩阵的实现方法
ccjjjjdff的博客
03-13 2125
稀疏矩阵的实现 什么是稀疏矩阵，怎么定义才是稀疏矩阵?假设在m x n的矩阵中，有t个不为0的元素。令z=t/(m x n),若z<=0.05则称此矩阵为稀疏矩阵。由于稀疏矩阵的非0元素较少，所以如果用大容量存储必定会造成内存浪费，因此只需存储非0元素值即可，以下列出了常用的三种存储稀疏矩阵的方法。 三元组顺序表 三元组顺序表的实现用顺序存储结构来实现。定义一个数组的结构体，存储的是三元组（即由 3 部分数据组成的集合），组中数据分别表示（行标，列标，元素值）。结构体的实现如下： ...
数据结构--稀疏矩阵的一种实现
weixin_38299404的博客
06-20 120
package main import ( "encoding/json" "fmt" "os" ) //定义一个结构体保存原始矩阵的信息 type sparseNode struct { Row int Col int Val int } //定义一个结构体保存反序列化后矩阵的信息 type unSparseNode struct { Row int Col int Val int } func main(){ //1.定义一个原始矩阵 var arr [11][11]int
c语言按矩阵形式输出稀疏矩阵代码,C语言经典算法 - 稀疏矩阵
weixin_36379666的博客
05-20 667
说明如果在矩阵中，多数的元素并没有资料，称此矩阵为稀疏矩阵(sparse matrix)， 由于矩阵在程式中常使用二维阵列表示，二维阵列的大小与使用的记忆体空间成正比，如果多数的元素没有资料，则会造成记忆体空间的浪费，为此，必须设计稀疏矩阵的阵列储存方式，利用较少的记忆体空间储存完整的矩阵资讯。解法在这边所介绍的方法较为简单，阵列只储存矩阵的行数、列数与有资料的索引位置及其值，在需要使用矩阵资料时...
[数据结构实验：稀疏矩阵]
weixin_30873847的博客
12-23 103
加法，乘法，转置： 1 加法，乘法，转置： 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 #include <string> 6 #include <cmath> 7 #include <a...
数据结构实验——稀疏矩阵
Flippped的博客
12-05 312
文章目录include.hTri.hmain.cppTriple.cpp最后的话 主要是稀疏矩阵的创建、输出、转置和快速转置 include.h #ifndef INCLUDE #define INCLUDE #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define OK 1 #define ERROR -1 #endif Tri.h
数据结构课程设计：稀疏矩阵（加、减、乘、求逆矩阵）
weixin_34242658的博客
01-08 384
经过一周的课设，课设终于接近尾声了，期间重写了3边，第一次是变量名太混乱，各种瞎胡搞，“ii kk”这些奇葩变量都用上了，这次是一个警钟吧，要记住。第二次重写是因为，参照学长博客，但用到了指针的东西，自己指针学的渣，怕给组员讲不懂，所以，有了这最后一个版本。自我感觉，最后一个版本写的还可以，不过还是有一个小小的bug，今天中午写说明书的时候发现的，加法（减法用加法实现，当然也有），在计算时，最后一...
稀疏矩阵与稀疏矩阵相乘
最新发布
07-23
稀疏矩阵与稀疏矩阵的乘法可以通过一种称为CSR（Compressed Sparse Row）格式的表示方法来实现。在CSR格式中，稀疏矩阵被存储为三个数组：一个存储非零元素的值数组，一个存储非零元素在每行中的列索引数组，以及一个存储每行中第一个非零元素的索引的偏移数组。 要进行稀疏矩阵与稀疏矩阵的乘法，可以按照以下步骤进行： 1. 将两个稀疏矩阵转换为CSR格式表示。 2. 对于第一个稀疏矩阵的每一行，找到与第二个稀疏矩阵的每一列相对应的非零元素。 3. 对于找到的这些非零元素，将它们的值相乘，并将结果累加到乘积矩阵的相应位置。 4. 最后，将乘积矩阵转换回常规的稀疏矩阵表示。 需要注意的是，稀疏矩阵与稀疏矩阵相乘后的结果仍然是一个稀疏矩阵，所以在进行乘法运算时可以利用稀疏矩阵的特点进行优化，减少计算量和存储空间的使用。 希望能帮到你！如果还有其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值