稀疏矩阵的三元组行逻辑链接的顺序表存储表示和实现（第五章 P101 算法5.3）

最新推荐文章于 2021-07-12 17:32:08 发布
最新推荐文章于 2021-07-12 17:32:08 发布
阅读量2.4k 收藏 29
点赞数 6
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42185999/article/details/105082423
版权

稀疏矩阵的三元组行逻辑链接的顺序表存储

 

三元组行逻辑链接顺序表存储结构：                                         采用三元组行逻辑链接存储稀疏矩阵的实例：

 

三元组行逻辑链接的顺序表存储表示 比三元组顺序表存储表示 增加 了 rpos 数组，用以存放各行的第一个非零元素在 data 数组中的位置。这样，就可以迅速地 找到某一行的元素。（创建稀疏矩阵输入非零元时，也要按行、列的顺序由小到大输入。）
 
 
  
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int ElemType;

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

#include<stdarg.h> /* 标准头文件，提供宏va_start，va_arg和va_end， */
/* 用于存取变长参数表 */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 



/* ---------------------------  稀疏矩阵的三元组行逻辑链接的顺序表存储表示  ------------------------------*/

#define MAXSIZE 100 /* 非零元个数的最大值 */
#define MAXRC 20 /* 最大行列数 */
typedef struct
{
	int i, j; /* 行下标,列下标 */
	ElemType e; /* 非零元素值 */
}Triple; /* 同c5-2.h */
typedef struct
{
	Triple data[MAXSIZE + 1]; /* 非零元三元组表,data[0]未用 */
	int rpos[MAXRC + 1]; /* 各行第一个非零元素的位置表,比c5-2.h增加的项 */
	int mu, nu, tu; /* 矩阵的行数、列数和非零元个数 */
}RLSMatrix;

/* ------------------------------------------------------------------------------------------*/



/* ---------------------------  行逻辑链接稀疏矩阵的基本操作(8个)  --------------------------*/

Status CreateSMatrix(RLSMatrix *M)
{ /* 创建稀疏矩阵M */
	int i;
	Triple T;
	Status k;
	printf("请输入矩阵的行数,列数,非零元素数：");
	scanf_s("%d,%d,%d", &(*M).mu, &(*M).nu, &(*M).tu);
	(*M).data[0].i = 0; /* 为以下比较做准备 */
	for (i = 1; i <= (*M).tu; i++)
	{
		do
		{
			printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),列(1～%d),元素值：", i, (*M).mu, (*M).nu);
			scanf_s("%d,%d,%d", &T.i, &T.j, &T.e);
			k = 0;
			if (T.i<1 || T.i>(*M).mu || T.j<1 || T.j>(*M).nu) /* 行、列超出范围 */
				k = 1;
			if (T.i < (*M).data[i - 1].i || T.i == (*M).data[i - 1].i&&T.j <= (*M).data[i - 1].j) /* 没有按顺序输入非零元素 */
				k = 1;
		} while (k); /* 当输入有误,重新输入 */
		(*M).data[i] = T;
	}
	for (i = 1; i <= (*M).tu; i++) /* 计算rpos[] */
		if ((*M).data[i].i > (*M).data[i - 1].i)
			for (T.i = 0; T.i < (*M).data[i].i - (*M).data[i - 1].i; T.i++)
				(*M).rpos[(*M).data[i].i - T.i] = i;
	for (i = (*M).data[(*M).tu].i + 1; i <= (*M).mu; i++) /* 给最后没有非零元素的几行赋值 */
		(*M).rpos[i] = (*M).tu + 1;
	return OK;
}

void DestroySMatrix(RLSMatrix *M)
{ /* 销毁稀疏矩阵M(使M为0行0列0个非零元素的矩阵) */
	(*M).mu = 0;
	(*M).nu = 0;
	(*M).tu = 0;
}

void PrintSMatrix(RLSMatrix M)
{ /* 输出稀疏矩阵M */
	int i;
	printf("%d行%d列%d个非零元素。\n", M.mu, M.nu, M.tu);
	printf("行  列  元素值\n");
	for (i = 1; 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]);
}

void PrintSMatrix1(RLSMatrix M)
{ // 按矩阵形式输出M
	int i, j, k = 1;
	Triple *p = M.data;
	p++; // p指向第1个非零元素
	for (i = 1; i <= M.mu; i++)
	{
		for (j = 1; j <= M.nu; j++)
			if (k <= M.tu&&p->i == i && p->j == j) // p指向非零元，且p所指元素为当前处理元素
			{
				printf("%3d", p->e); // 输出p所指元素的值
				p++; // p指向下一个元素
				k++; // 计数器+1
			}
			else // p所指元素不是当前处理元素
				printf("%3d", 0); // 输出0
			printf("\n");
	}
}

Status CopySMatrix(RLSMatrix M, RLSMatrix *T)
{ /* 由稀疏矩阵M复制得到T */
	*T = M;
	return OK;
}

Status AddSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix *Q)
{ /* 求稀疏矩阵的和Q=M+N */
	int k, p, q;
	if (M.mu != N.mu || M.nu != N.nu)
		return ERROR;
	(*Q).mu = M.mu;
	(*Q).nu = M.nu;
	(*Q).tu = 0;
	M.rpos[M.mu + 1] = M.tu + 1; /* 为方便后面的while循环临时设置 */
	N.rpos[N.mu + 1] = N.tu + 1;
	for (k = 1; k <= M.mu; ++k) /* 对于每一行，k指示行号 */
	{
		(*Q).rpos[k] = (*Q).tu + 1;
		p = M.rpos[k]; /* p指示M矩阵第k行当前元素的序号 */
		q = N.rpos[k]; /* q指示N矩阵第k行当前元素的序号 */
		while (p < M.rpos[k + 1] && q < N.rpos[k + 1])
		{ /* M,N矩阵均有第k行元素未处理 */
			if (M.data[p].j == N.data[q].j) /* M矩阵当前元素和N矩阵当前元素的列相同 */
			{
				(*Q).data[(*Q).tu + 1].e = M.data[p].e + N.data[q].e;
				if ((*Q).data[(*Q).tu + 1].e != 0)
				{
					++(*Q).tu;
					(*Q).data[(*Q).tu].i = k;
					(*Q).data[(*Q).tu].j = M.data[p].j;
				}
				++p;
				++q;
			}
			else if (M.data[p].j < N.data[q].j)
			{ /* M矩阵当前元素的列<N矩阵当前元素的列 */
				++(*Q).tu;
				(*Q).data[(*Q).tu].e = M.data[p].e;
				(*Q).data[(*Q).tu].i = k;
				(*Q).data[(*Q).tu].j = M.data[p].j;
				++p;
			}
			else /* M矩阵当前元素的列>N矩阵当前元素的列 */
			{
				++(*Q).tu;
				(*Q).data[(*Q).tu].e = N.data[q].e;
				(*Q).data[(*Q).tu].i = k;
				(*Q).data[(*Q).tu].j = N.data[q].j;
				++q;
			}
		}
		while (p < M.rpos[k + 1]) /* M矩阵还有k行的元素未处理 */
		{
			++(*Q).tu;
			(*Q).data[(*Q).tu].e = M.data[p].e;
			(*Q).data[(*Q).tu].i = k;
			(*Q).data[(*Q).tu].j = M.data[p].j;
			++p;
		}
		while (q < N.rpos[k + 1]) /* N矩阵还有k行的元素未处理 */
		{
			++(*Q).tu;
			(*Q).data[(*Q).tu].e = N.data[q].e;
			(*Q).data[(*Q).tu].i = k;
			(*Q).data[(*Q).tu].j = N.data[q].j;
			++q;
		}
	}
	return OK;
}

Status SubtSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix *Q)
{ /* 求稀疏矩阵的差Q=M-N */
	int i;
	if (M.mu != N.mu || M.nu != N.nu)
		return ERROR;
	for (i = 1; i <= N.tu; ++i) /* 对于N的每一元素,其值乘以-1 */
		N.data[i].e *= -1;
	AddSMatrix(M, N, Q); /* Q=M+(-N) */
	return OK;
}

Status MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix *Q)
{ /* 求稀疏矩阵乘积Q=M＊N。算法5.3 */
	int arow, brow, p, q, ccol, ctemp[MAXRC + 1];
	if (M.nu != N.mu) /* 矩阵M的列数应和矩阵N的行数相等 */
		return ERROR;
	(*Q).mu = M.mu; /* Q初始化 */
	(*Q).nu = N.nu;
	(*Q).tu = 0;
	M.rpos[M.mu + 1] = M.tu + 1; /* 为方便后面的while循环临时设置 */
	N.rpos[N.mu + 1] = N.tu + 1;
	if (M.tu*N.tu != 0) /* M和N都是非零矩阵 */
	{
		for (arow = 1; arow <= M.mu; ++arow)
		{ /* 从M的第一行开始，到最后一行，arow是M的当前行 */
			for (ccol = 1; ccol <= (*Q).nu; ++ccol)
				ctemp[ccol] = 0; /* Q的当前行的各列元素累加器清零 */
			(*Q).rpos[arow] = (*Q).tu + 1; /* Q当前行的第1个元素位于上1行最后1个元素之后 */
			for (p = M.rpos[arow]; p < M.rpos[arow + 1]; ++p)
			{ /* 对M当前行中每一个非零元 */
				brow = M.data[p].j; /* 找到对应元在N中的行号(M当前元的列号) */
				for (q = N.rpos[brow]; q < N.rpos[brow + 1]; ++q)
				{
					ccol = N.data[q].j; /* 乘积元素在Q中列号 */
					ctemp[ccol] += M.data[p].e*N.data[q].e;
				}
			} /* 求得Q中第arow行的非零元 */
			for (ccol = 1; ccol <= (*Q).nu; ++ccol) /* 压缩存储该行非零元 */
				if (ctemp[ccol])
				{
					if (++(*Q).tu > MAXSIZE)
						return ERROR;
					(*Q).data[(*Q).tu].i = arow;
					(*Q).data[(*Q).tu].j = ccol;
					(*Q).data[(*Q).tu].e = ctemp[ccol];
				}
		}
	}
	return OK;
}

Status TransposeSMatrix(RLSMatrix M, RLSMatrix *T)
{ /* 求稀疏矩阵M的转置矩阵T */
	int p, q, t, col, *num;
	num = (int *)malloc((M.nu + 1) * sizeof(int));
	(*T).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) /* 求M中每一列非零元个数 */
			++num[M.data[t].j];
		(*T).rpos[1] = 1;
		for (col = 2; col <= M.nu; ++col) /* 求M中第col中第一个非零元在(*T).data中的序号 */
			(*T).rpos[col] = (*T).rpos[col - 1] + num[col - 1];
		for (col = 1; col <= M.nu; ++col)
			num[col] = (*T).rpos[col];
		for (p = 1; p <= M.tu; ++p)
		{
			col = M.data[p].j;
			q = num[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;
			++num[col];
		}
	}
	free(num);
	return OK;
}

/* ------------------------------------------------------------------------------------------*/


/*  检验以上操作的主程序 */

void main()
{
	RLSMatrix A, B, C; 
	printf("创建矩阵A: ");
	CreateSMatrix(&A);
	PrintSMatrix1(A);
	printf("由矩阵A复制矩阵B: ");
	CopySMatrix(A, &B);
	PrintSMatrix1(B);
	DestroySMatrix(&B);
	printf("销毁矩阵B后:\n");
	PrintSMatrix1(B);
	printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n", A.mu, A.nu);
	CreateSMatrix(&B);
	PrintSMatrix1(B);
	printf("矩阵C1(A+B): ");
	AddSMatrix(A, B, &C);
	PrintSMatrix1(C);
	DestroySMatrix(&C);
	printf("矩阵C2(A-B): ");
	SubtSMatrix(A, B, &C);
	PrintSMatrix1(C);
	DestroySMatrix(&C);
	printf("矩阵C3(A的转置): ");
	TransposeSMatrix(A, &C);
	PrintSMatrix1(C);
	DestroySMatrix(&A);
	DestroySMatrix(&B);
	DestroySMatrix(&C);
	printf("创建矩阵A2: ");
	CreateSMatrix(&A);
	PrintSMatrix1(A);
	printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n", A.nu);
	CreateSMatrix(&B);
	PrintSMatrix1(B);
	printf("矩阵C5(A*B): ");
	MultSMatrix(A, B, &C);
	PrintSMatrix1(C);
	DestroySMatrix(&A);
	DestroySMatrix(&B);
	DestroySMatrix(&C);
}

运行结果：

想去的远方
关注
专栏目录
DAMA 数据管理知识体系指南：第五章 数据模型与设计
云祁QI
05-29 1023
关系捕获概念实体之间的高级别交互、逻辑实体之间的详细交互、物理实体之间的约束。第五章是 CDGA|CDGP 考试的重点考核章节之一，分值占比高，知识点比较密集，重点考查知识点包括：数据建模的定义、6 种数据模型及建模方法、业务驱动因素、数据模型目标与原则、数据模型组件、建模的数据类型、数据模型级别、数据建模和设计活动等。实体中属性的物理展现为表、视图、文档、图形或文件中的列、字段、标记或节点等。概念数据模型仅包括给定的领域和职能中基础和关键的业务实体，同时也给出实体和实体之间关系的描述。
【定位模型】基于UWB技术三点定位（Trilateration）算法仿真实现
Fanjufei的博客
12-08 249
三点定位（Trilateration）算法的实现示例，基于论文 "An algebraic solution to the multilateration problem"。该算法用于通过已知的参考点和与这些点的距离来估计目标点的位置。
稀疏矩阵的三元组顺序表存储表示及其转置算法
11-02
//稀疏矩阵的三元组顺序表存储表示 #define MAXSIZE 100 //非零元个数最大为100 typedef struct {int i,j; //非零元的行下标和列下标 ElemType e; //非零元 }Triple; typedef struct {Triple data[MAXSIZE+1]; //非零元三元组表,data[0]不用 int mu,nu,tu; //矩阵的总行数,总列数,非零元总个数 }TSMatrix;
稀疏矩阵的存储与获取(行逻辑链接顺序表 C++版)
weixin_42295110的博客
07-12 558
行逻辑链接顺序表实现稀疏矩阵的存储和获取。 行逻辑链接顺序表其实就是一个加强版的三元组顺序表,在三元组顺序表的基础之上改善了提取数据的效率。它只不过是增加了一个数组,用来记录每行的非零元素在一维数组中的位置。 这样,当我们获取某行的某个元素时,不必再把矩阵的非零元素整个都遍历一遍,而是只遍历与该行相关的非零元素。 时间复杂度较三元组顺序表大大降低。但是多了一个数组的存储空间的开销。 代码实现及结果测试: #include<stdio.h> #include<stdli...
稀疏矩阵的三元组行逻辑链接的顺序表存储结构表示及实现
08-07 2926
#define MAX_SIZE 100 #define MAX_RC 20struct Triple { int i, j;//行下标，列下标 ElemType e;//非零元素值 };struct RLSMatrix { Triple data[MAX_SIZE + 1];//非零元三元组表，data[0]未用 int rpos[MAX_RC + 1];//各行第
稀疏矩阵的行逻辑连接顺序表实现
The Fallen Angel
11-20 1400
下面的程序搞了我半天……         一点遗憾是： 加法运算中rpos数组成了累赘。rpos的计算无法镶嵌到加法运算过程中（即大循环里面），尝试了多种方法亦无果（大多时间就浪费在这）。最后只能单独计算。C创建动态数组比较麻烦，所以定义中间数组时没有用动态数组，只能用行列数的最大值MAXRC作为数组元素个数。纯C实现，如果是C++，可重载运算符。         还有，那啥，Visual A
行逻辑连接的顺序表实现稀疏矩阵乘法
NineKing
09-30 2048
行逻辑连接顺序表 采用一位三元结构体组记录的每一个元素在矩阵中的具体位置，采用一维数组记录每行第一个非元素的位置，具有记录行数，列数和非元素总个数的结构体成员变量。 算法思想 逐行求积，每次处理一行，设立一个一维数组ctemp对应乘积结果中的对应行元素构成的数组。 将前乘矩阵M当前行的非0元素找到对应在后乘矩阵N中的对应行，依次去乘其行中每一列的非0元素，然后累加到ctemp对应的元...
稀疏矩阵——行逻辑连接的顺序三元组表
慢慢的专栏
08-14 2421
#include using namespace std; #define MAXSIZE 20 #define MAXNUM 20 #define MAXCPOT 20 #define MAXRC 20 #define MAXCTEMP 20 #define ok 1 #define error 0 typedef int Status; template class Triple{ tem
bp算法和nlp算法_西瓜书5.5 编程实现BP神经网络——标准BP算法、累积BP算法
weixin_39607710的博客
12-21 1031
这里照着书上的公式，实现了一下标准BP算法，和累积BP算法，BP是error Back Propagation的意思，误差逆传播。BP网络通常是指用BP算法训练的多层前馈神经网络。代码是照着书本公式自己写的，没有参考网上的其他版本。数据和代码地址：https://github.com/qdbszsj/BP具体的理论证明和公式推导，见西瓜书P101-104。这里重点说一下我的数据处理和一些代码细节，...
快思聪培训CTI-P101中文大纲
12-02
这三个概念是编程中最重要的环节，因为任何程序都是围绕这三个环节进行设计和实现的。 大纲还介绍了编程的五个方面，分别是需求、设计、实施、检验和维护。需求阶段涉及与用户沟通，创建工作范围，确定程序能完成的...
基于蚁群算法实现寻找最优路径matlab源码+项目说明+超详细注释.zip
最新发布
03-04
参考:《智能优化算法及其MATLAB实例（第2版）》by包子阳 P101 例5.1 对结果的显示进行一定修改，以查看每一次迭代的最佳结果： ![代码修改](./imgs/0.jpg) ![地图](./imgs/6.jpg) Dijkstra算法示例中求出的最优...
顺序存储结构的三元组稀疏矩阵的乘法运算
热门推荐
JessicaWin
06-07 1万+
三元组形式的二维稀疏矩阵的乘法运算
稀疏矩阵----三元组顺序表建立、转置
壑壑哒的博客
11-16 7708
对于稀疏矩阵，采用压缩存储方法时，只存储非0元素。必须存储非0元素的行下标值、列下标值、元素值。因此，一个三元组(i, j, aij)唯一确定稀疏矩阵的一个非零元素。 若以行序为主序，稀疏矩阵中所有非0元素的三元组，就可得构成该稀疏矩阵的一个三元组顺序表。    代码： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define ...
c语言三元组作用,三元组顺序表，稀疏矩阵的三元组表示及（C语言）实现
weixin_29628479的博客
05-16 1302
本节介绍稀疏矩阵的三元组顺序表压缩存储方式。通过《矩阵的压缩存储》一节我们知道，稀疏矩阵的压缩存储，至少需要存储以下信息：矩阵中各非 0 元素的值，以及所在矩阵中的行标和列标；矩阵的总行数和总列数；图 1 稀疏矩阵示意图例如，图 1 是一个稀疏矩阵，若对其进行压缩存储，矩阵中各非 0 元素的存储状态如图 2 所示：图 2 稀疏矩阵的压缩存储示意图图 2 的数组中，存储的是三元组(即由 3 部分数据...
【数据结构】稀疏矩阵的顺序表示
WINGREZ‘S BLOG
09-11 990
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 稀疏矩阵的顺序表示 三元组顺序表 #define MAXSIZE 12500 //非零元的最大个数 typ...
稀疏矩阵的三元组存储方法c语言,数据结构C语言版 稀疏矩阵的三元组顺序表存储表示和实现...
weixin_28820911的博客
05-18 1532
陈独秀的秘密数据结构C语言版 稀疏矩阵的三元组顺序表存储表示和实现P98编译环境：Dev-C++ 4.9.9.2日期：2011年2月8日*/typedef int ElemType;// 稀疏矩阵的三元组顺序表存储表示#define MAXSIZE 100 // 非零元个数的最大值typedef struct{int i,j; // 行下标,列下标ElemType e; // 非零元...
第五章（3）行逻辑链接的顺序表
风吹无迹雨落无痕
04-26 5336
//三元组顺序表又称有序的双下标法，它的特点是：非零元在表中按行序列有序存储，因此便于进行依行顺序处理的矩阵运算。//然而若需要按行号存取某一行的非零元，则需要从头开始查找。//为便于随机存取任意一行的非零元，则需知道每一行的第一个非零元在三元组表中的位置。//为此,可将上节快速转置矩阵的算法中创建的，指示“行”信息的辅助数组cpot固定在稀疏矩阵的存储结构中，这种“带行链接信息”的三元组表为行逻
稀疏矩阵及存储c语言代码,稀疏矩阵的存储和运算
weixin_34234741的博客
05-18 1354
稀疏矩阵的存储和运算一 目的根据所学知识，编写指定题目的C语言程序，并规范地完成课程设计报告。通过课程设计，加深对《程序设计语言》和《软件技术基础》课程所学知识的理解，熟练掌握和巩固C语言的基本知识和语法规范，包括：数据类型(整形、实型、字符型、指针、数组、结构等)；运算类型(算术运算、逻辑运算、自增自减运算、赋值运算等)；程序结构(顺序结构、判断选择结构、循环结构)；库函数应用等；复杂任务功能分...
稀疏矩阵的三元组顺序表存储结构表示及实现
08-07 5314
#define MAX_SIZE 100struct Triple { int i, j;//行下标，列下标 ElemType e;//非零元素值 };struct TSMatrix { Triple data[MAX_SIZE + 1];//非零元三元组表，data[0]未用 int mu, nu, tu;//矩阵的行数，列数，非零元个数 }; int comp(i
优化存储：顺序表与链表的高效实现
文档中提到的存储表示涉及两种情况：一种是针对指数连续排列的多项式，例如P101(x) = 3 + 5x^50 - 14x^101，采用的是动态数组（degree和coef数组）来存储各个系数，这种设计对这类特定模式的多项式存储效率较高。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值