十字链表实现矩阵

最新推荐文章于 2021-11-12 01:00:44 发布
最新推荐文章于 2021-11-12 01:00:44 发布
阅读量1k 收藏 7
点赞数 1
分类专栏： 数据结构与算法分析学习笔记 文章标签： 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shayabean_/article/details/45368637
版权
本文详细介绍了如何利用十字链表来高效地实现矩阵的各种操作，如增删元素、矩阵相加和乘法等。通过十字链表的特殊结构，可以方便地进行行列遍历，提高数据访问速度。
摘要由CSDN通过智能技术生成 
#ifndef CROSSMATRIX_H_
#define CROSSMATRIX_H_


#define FLOWOVER -1
struct SCMNode;//节点
typedef int elemType;//数据域数据类型
typedef struct SCMNode * CMNode;//指向节点的指针


/**************结构体声明与定义**************/


struct SCMNode{
<span style="white-space:pre">	</span>int row;//节点行号
<span style="white-space:pre">	</span>int col;//节点列号
<span style="white-space:pre">	</span>elemType elem;//节点的数值
<span style="white-space:pre">	</span>struct SCMNode * right;//指向节点右侧的下个非零元,若没有则为NULL
<span style="white-space:pre">	</span>struct SCMNode * down;//指向节点下方的下个非零元,若没有则为NULL
};


typedef struct{
<span style="white-space:pre">	</span>CMNode *rowhead;//指针数组,rowhead[1],存的是矩阵第1行第一个节点的地址,若为空行,值为NULL
<span style="white-space:pre">	</span>CMNode *colhead;//指针数组,colhead[1],存的是矩阵第1列第一个节点的地址,若为空列,值为NULL
<span style="white-space:pre">	</span>int numOfRow;//表示矩阵的总行数
<span style="white-space:pre">	</span>int numOfCol;//表示矩阵的总列数
<span style="white-space:pre">	</span>int numOfElem;//表示矩阵的非零元总数
}CrossMatrix;//表头,不是指针,代表十字矩阵本身




/**************方法声明**************/


//创建一个新节点,为后续一些方法的辅助函数
void NewNdoe(CMNode &N, int r, int c, elemType e);
//输入行列数,创建一个空稀疏矩阵
void CreatMatrix(CrossMatrix &CM, int nR, int nC);
//构建并赋值,初始化一个新稀疏矩阵
void InitMatrix(CrossMatrix &CM, int nR, int nC, int nE);
//清空稀疏矩阵
void ClearMatrix(CrossMatrix &CM);
//输出稀疏矩阵
void PrintMatrix(CrossMatrix &CM);
//在输入指针指向的节点左方增加一个新节点,为下面几个运算的辅助函数
void AddNode(CrossMatrix &A, CMNode newN, int r, int c, elemType e);
//删除指定矩阵的指定节点,为下面几个运算的辅助函数
void DeleteNode(CrossMatrix &A, CMNode rowOfA);
//M、N行列数相同,将矩阵M、N相加赋值给M,M = M + Ｎ
void AddMatrix(CrossMatrix &M, CrossMatrix N);
//M、N行列数相同,将矩阵M、N相减赋值给M,M = M - Ｎ
void SubMatrix(CrossMatrix &M, CrossMatrix N);
//M行数等于N列数,M列数等于N行数,将矩阵M、N相乘赋值给Q,Q = M * Ｎ
void MultMatrix(CrossMatrix &Q, CrossMatrix M, CrossMatrix N);
//M转置得到T
void TransposeMatrix(CrossMatrix &T, CrossMatrix M);


#endif


#include "CrossMatrix.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#pragma warning(disable:4996)

void NewNdoe(CMNode &N, int r, int c, elemType e)
{
	N = (CMNode)malloc(sizeof(struct SCMNode));
	if (N == NULL)
		exit(FLOWOVER);
	N->row = r;
	N->col = c;
	N->elem = e;
	N->right = NULL;
	N->down = NULL;
}

void CreatMatrix(CrossMatrix &CM, int nR, int nC)
{//若输入的结构体不是空结构体，如何判定
	CM.numOfRow = nR;
	CM.numOfCol = nC;
	CM.numOfElem = 0;
	CM.rowhead = (CMNode *)malloc(sizeof(CMNode) * (nR + 1));
	if (CM.rowhead == NULL)
		exit(FLOWOVER);
	CM.colhead = (CMNode *)malloc(sizeof(CMNode) * (nC + 1));
	if (CM.colhead == NULL)
		exit(FLOWOVER);
	//头结点初始化,CM.rowhead[0]废弃不用,将头结点也分配空间是为了统一所有节点的插入操作
	for (int i = 1; i <= nR; i++){
		CM.rowhead[i]= NULL; 
	}
	for (int i = 1; i <= nC; i++){
		CM.colhead[i] = NULL;
	}
}

void InitMatrix(CrossMatrix &CM, int nR, int nC, int nE)
{//若输入的结构体不是空结构体，如何判定
	CM.numOfRow = nR;
	CM.numOfCol = nC;
	CM.numOfElem = nE;
	CM.rowhead = (CMNode *)malloc(sizeof(CMNode) * (nR + 1));
	if (CM.rowhead == NULL)
		exit(FLOWOVER);
	CM.colhead = (CMNode *)malloc(sizeof(CMNode) * (nC + 1));
	if (CM.colhead == NULL)
		exit(FLOWOVER);
	//头结点初始化,CM.rowhead[0]废弃不用
	for (int i = 1; i <= nR; i++){
		CM.rowhead[i] = NULL;
	}
	for (int i = 1; i <= nC; i++){
		CM.colhead[i] = NULL;
	}

	printf("分别输入%d个由行、列、数值构成的三元组:", nE);
	for (int i = 1; i <= nE; i++){
		CMNode Node = NULL;
		int r, c, e;//这里的e如何控制输入为double等其他类型时正常运行
		scanf("%d%d%d", &r, &c, &e);
		NewNdoe(Node, r, c, e);
		//行插入
		if (CM.rowhead[r] == NULL || CM.rowhead[r]->col > Node->col){
			Node->right = CM.rowhead[r];
			CM.rowhead[r] = Node;
		}
		else{
			CMNode tempNode = CM.rowhead[r];//循环结束后存的是插入节点的后继
			CMNode frontOfTempNode = NULL;//循环结束后存的是插入节点的前驱
			while (tempNode != NULL && tempNode->col < Node->col){
				frontOfTempNode = tempNode;
				tempNode = tempNode->right;
			}
			frontOfTempNode->right = Node;
			Node->right = tempNode;
		}
		//列插入
		if (CM.colhead[c] == NULL || CM.colhead[c]->row > Node->row){
			Node->down = CM.colhead[c];
			CM.colhead[c] = Node;
		}
		else{
			CMNode tempNode = CM.colhead[c];
			CMNode frontOfTempNode = NULL;
			while (tempNode != NULL && tempNode->row < Node->row){
				frontOfTempNode = tempNode;
				tempNode = tempNode->down;
			}
			frontOfTempNode->down = Node;
			Node->down= tempNode;
		}
	}
}

void ClearMatrix(CrossMatrix &CM)
{
	CMNode tempNode;
	for (int i = 1; i <= CM.numOfRow; i++){
		while (CM.rowhead[i] != NULL){
			tempNode = CM.rowhead[i];
			CM.rowhead[i] = CM.rowhead[i]->right;
			free(tempNode);
		}
	}

	free(CM.rowhead);
	free(CM.colhead);
	CM.numOfRow = 0;
	CM.numOfCol = 0;
	CM.numOfElem = 0;
	CM.rowhead = NULL;
	CM.colhead = NULL;
}

void PrintMatrix(CrossMatrix &CM)
{
	CMNode tempNode = NULL;
	for (int i = 1; i <= CM.numOfRow; i++){
		tempNode = CM.rowhead[i];
		for (int j = 1; j <= CM.numOfCol; j++){
			if (tempNode != NULL && tempNode->col == j){
				printf("%d ", tempNode->elem);
				tempNode = tempNode->right;
			}
			else{
				printf("%d ", 0);
			}
		}
		printf("\n");
	}
}

void AddNode(CrossMatrix &A, CMNode newN, int r, int c, elemType e)
{//rearOfRow是新节点的行后继
	CMNode frontOfRow = NULL;//最终存储新节点的行前驱
	CMNode rearOfRow = NULL;//最终存储新节点的行后继
	CMNode frontOfCol = NULL;//最终存储新节点的列前驱
	CMNode rearOfCol = NULL;//最终存储新节点的列后继
	NewNdoe(newN, r, c, e);
	//行插入
	if (A.rowhead[r] == NULL){//这个和下面的else if能不能合并？
		newN->right = A.rowhead[r];
		A.rowhead[r] = newN;
		A.numOfElem++;
	}
	else if (A.rowhead[r]->col > newN->col){
		newN->right = A.rowhead[r];
		A.rowhead[r] = newN;
		A.numOfElem++;
	}
	else{
		frontOfRow = A.rowhead[r];
		rearOfRow = A.rowhead[r];
		while (rearOfRow != NULL && rearOfRow->col < newN->col){
			rearOfRow = rearOfRow->right;
		}
		while (frontOfRow->right != rearOfRow){
			frontOfRow = frontOfRow->right;
		}
		newN->right = rearOfRow;
		frontOfRow->right = newN;
		A.numOfElem++;
	}
	//列插入
	if (A.colhead[c] == NULL){//这个和下面的else if能不能合并？
		newN->down = A.colhead[c];
		A.colhead[c] = newN;
	}
	else if (A.colhead[c]->row > newN->row){
		newN->down = A.colhead[c];
		A.colhead[c] = newN;
	}
	else{
		frontOfCol = A.colhead[c];
		rearOfCol = A.colhead[c];
		while (rearOfCol != NULL && rearOfCol->row < newN->row){
			rearOfCol = rearOfCol->down;
		}
		while (frontOfCol->down != rearOfCol){
			frontOfCol = frontOfCol->down;
		}
		newN->down = rearOfCol;
		frontOfCol->down = newN;
	}
}

void DeleteNode(CrossMatrix &A, CMNode rowOfA)
{//rowOfA为被删除节点地址
	CMNode rearOfRow = rowOfA->right;//被删除节点的行后继
	CMNode frontOfRow = A.rowhead[rowOfA->row];//被删除节点的行前驱
	CMNode rearOfCol = rowOfA->down;//被删除节点的列后继
	CMNode frontOfCol = A.colhead[rowOfA->col];//被删除节点的列前驱

	//行删除
	if (frontOfRow == rowOfA){//删除的节点为行第一个节点
		A.rowhead[rowOfA->row] = rearOfRow;
	}
	else{//删除的节点不是行第一个节点
		while (frontOfRow->right != rowOfA){
			frontOfRow = frontOfRow->right;
		}
		frontOfRow->right = rearOfRow;
	}
	//列删除
	if (frontOfCol == rowOfA){//删除的节点为列第一个节点
		A.colhead[rowOfA->col] = rearOfCol;
	}
	else{//删除的节点不是列第一个节点
		while (frontOfCol->down != rowOfA){
			frontOfCol = frontOfCol->down;
		}
		frontOfCol->down = rearOfCol;
	}

	free(rowOfA);
	A.numOfElem--;
}

void AddMatrix(CrossMatrix &M, CrossMatrix N)
{
	CMNode rowOfM;//指向M从行看的某个节点的指针
	CMNode rowOfN;//指向N从行看的某个节点的指针

	for (int i = 1; i <= M.numOfRow; i++){
		rowOfM = M.rowhead[i];
		rowOfN = N.rowhead[i];

		if (rowOfN == NULL)
			continue;

		if (rowOfM == NULL){
			while (rowOfN != NULL){
				CMNode tempNode = NULL;
				rowOfM = M.rowhead[i];
				AddNode(M, tempNode, rowOfN->row, rowOfN->col, rowOfN->elem);
				rowOfM = rowOfM->right;
				rowOfN = rowOfN->right;
			}
		}
		else{
			while (rowOfM != NULL && rowOfN != NULL){
				if (rowOfM->col > rowOfN->col){
					CMNode tempNode = NULL;
					CMNode rearOfNewNode = M.rowhead[i];//rowOfM的行后继
					while (rearOfNewNode != rowOfM->right){
						rearOfNewNode = rearOfNewNode->right;
					}
					AddNode(M, tempNode, rowOfN->row, rowOfN->col, rowOfN->elem);
					rowOfN = rowOfN->right;
				}
				else if (rowOfM->col < rowOfN->col){
					rowOfM = rowOfM->right;
				}
				else if (rowOfM->col == rowOfN->col && rowOfM->elem + rowOfN->elem != 0){
					rowOfM->elem = rowOfM->elem + rowOfN->elem;
					rowOfM = rowOfM->right;
					rowOfN = rowOfN->right;
				}
				else{
					CMNode tempNodeM = rowOfM->right;
					DeleteNode(M, rowOfM);
					rowOfM = tempNodeM;
					rowOfN = rowOfN->right;
				}
			}
		}
	}
}

void SubMatrix(CrossMatrix &M, CrossMatrix N)
{
	CMNode rowOfM;//指向M从行看的某个节点的指针
	CMNode rowOfN;//指向N从行看的某个节点的指针

	for (int i = 1; i <= M.numOfRow; i++){
		rowOfM = M.rowhead[i];
		rowOfN = N.rowhead[i];

		if (rowOfN == NULL)
			continue;

		if (rowOfM == NULL){
			while (rowOfN != NULL){
				CMNode tempNode = NULL;
				rowOfN = M.rowhead[i];
				AddNode(M, tempNode, rowOfN->row, rowOfN->col, -rowOfN->elem);
				rowOfM = rowOfM->right;
				rowOfN = rowOfN->right;
			}
		}
		else{
			while (rowOfM != NULL && rowOfN != NULL){
				if (rowOfM->col > rowOfN->col){
					CMNode tempNode = NULL;
					CMNode rearOfNewNode = M.rowhead[i];//rowOfM的行后继
					while (rearOfNewNode != rowOfM->right){
						rearOfNewNode = rearOfNewNode->right;
					}
					AddNode(M, tempNode, rowOfN->row, rowOfN->col, -rowOfN->elem);
					rowOfN = rowOfN->right;
				}
				else if (rowOfM->col < rowOfN->col){
					rowOfM = rowOfM->right;
				}
				else if (rowOfM->col == rowOfN->col && rowOfM->elem - rowOfN->elem != 0){
					rowOfM->elem = rowOfM->elem - rowOfN->elem;
					rowOfM = rowOfM->right;
					rowOfN = rowOfN->right;
				}
				else{
					CMNode tempNodeM = rowOfM->right;
					DeleteNode(M, rowOfM);
					rowOfM = tempNodeM;
					rowOfN = rowOfN->right;
				}
			}
		}
	}
}

void MultMatrix(CrossMatrix &Q, CrossMatrix M, CrossMatrix N)
{
	CMNode rowOfM;//指向M从行看的某个节点的指针
	CMNode colOfN;//指向N从列看的某个节点的指针
	CreatMatrix(Q, M.numOfRow, N.numOfCol);

	for (int i = 1; i <= M.numOfRow; i++){
		rowOfM = M.rowhead[i];
		if (rowOfM == NULL)
			continue;
		for (int j = 1; j <= N.numOfCol; j++){
			rowOfM = M.rowhead[i];//轮完一轮重置
			colOfN = N.colhead[j];
			if (colOfN == NULL)
				break;

			int tempSum = 0;
			while (rowOfM != NULL && colOfN != NULL){
				if (rowOfM->col > colOfN->row){
					colOfN = colOfN->down;
				}
				else if (rowOfM->col < colOfN->row){
					rowOfM = rowOfM->right;
				}
				else{
					tempSum += rowOfM->elem * colOfN->elem;
					rowOfM = rowOfM->right;
					colOfN = colOfN->down;
				}
			}
			if (tempSum != 0){
				CMNode tempNode = NULL;
				AddNode(Q, tempNode, i, j, tempSum);
			}
		}
	}
}

void TransposeMatrix(CrossMatrix &T, CrossMatrix M)
{
	CMNode tempOfRow;
	CreatMatrix(T, M.numOfCol, M.numOfRow);
	for (int i = 1; i <= M.numOfRow; i++){
		tempOfRow = M.rowhead[i];
		while (tempOfRow != NULL){
			AddNode(T, tempOfRow, tempOfRow->col, tempOfRow->row, tempOfRow->elem);
			tempOfRow = tempOfRow->right;
		}
	}
}






#include "CrossMatrix.h"
#include <stdio.h>
#include <stdlib.h>

int main()
{
	CrossMatrix testM;
	CrossMatrix testN;
	CrossMatrix testQ;

	/*初始化测试*/
	//InitMatrix(testM, 3, 4, 4);//1 1 2 2 2 1 3 3 3 1 4 1
	//PrintMatrix(testM);
	//InitMatrix(testN, 3, 4, 4);//3 1 1 2 2 2 1 3 1 3 3 -3
	//PrintMatrix(testN);

	/*加法测试*/
	//AddMatrix(testM, testN);
	//PrintMatrix(testM);

	/*减法测试*/
	//SubMatrix(testM, testN);
	//PrintMatrix(testM);

	/*乘法测试*/
	//InitMatrix(testM, 3, 4, 4); //1 1 2 2 2 1 3 3 3 1 4 1
	//PrintMatrix(testM);    
	//InitMatrix(testN, 4, 3, 4); //3 1 1 2 2 2 3 3 -3 1 3 1
	//PrintMatrix(testN);
	//MultMatrix(testQ, testM, testN);
	//PrintMatrix(testQ);

	//转置测试
	InitMatrix(testM, 3, 4, 4);//1 1 2 2 2 1 3 3 3 1 4 1
	PrintMatrix(testM);
	TransposeMatrix(testQ, testM);
	PrintMatrix(testQ);

	system("pause");
}



Shayabean_
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
稀疏矩阵的十字链表表示方法：矩阵加减乘法运算、矩阵转置运算、矩阵项的插入、矩阵行列链表的排序
06-08
稀疏矩阵的十字链表表示方法：矩阵加减乘法运算、矩阵转置运算、矩阵项的插入、矩阵行列链表的排序
十字链表矩阵
weixin_30244681的博客
04-16 302
数据结构的十字链表矩阵要一开始的行列的表头要相互连接来表示邻接关系 这里用数组表示邻接也不浪费空间 写了Serach( i , j );函数可以寻找矩阵位置为i j数值 然后加，减，乘，也就方便了…… 至于算法复杂度嘛……因为懒所以直接用Search()了（所以矩阵运算比想象中复杂度高……）……23333333 代码…… #include <iostream> #in...
十字链表构建矩阵
zhoutonglx的专栏
12-29 846
#include #include using namespace std; typedef struct Onode { int e; int i,j; Onode* right; Onode* down; }*ONode; typedef struct Olink { Onode** rowhead; Onode** colhead; int m; int n; int l
十字链表表示矩阵c语言,十字链表的定义及C语言描述
weixin_33454551的博客
05-21 535
十字链表常用于表示稀疏矩阵，可视作稀疏矩阵的一种链式表示，因此，这里以稀疏矩阵为背景介绍十字链表。不过，十字链表的应用远不止稀疏矩阵，一切具有正交关系的结构，都可用十字链表存储。1、存储方式(a)稀疏矩阵中每个非0元素对应一个十字链表结点，每个结点的结构为 其中各字段的含意为：row──元素在稀疏矩阵中的行号col──元素在稀疏矩阵中的列号val──元素值down──指向同列中下一个非0元素结点r...
基于十字链表存储的稀疏矩阵的转置
04-28
实现了从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构（m、n分别表示矩阵行数和列数；i, j为非零元素行号和列号）和十字链表的转置并将转置后的三元组到另一字符文件中
十字链表实现矩阵相加
12-09
在学习《数据结构（C语言版）》中第五章稀疏矩阵时，课本提示使用十字链表实现矩阵相加，没能运行，于是自己调试实现了下，希望对大家有帮助
十字链表实现稀疏矩阵的各种功能
11-19
十字链表实现稀疏矩阵的加法、减法、乘法、转置、求最值、插入、查看、删除等基本功能，菜单栏采用hash表存储稀疏矩阵，给每个矩阵存储一个名字，hash函数进行寻找。
十字链表实现稀疏矩阵的加法
12-10
十字链表实现稀疏矩阵的加法 稀疏矩阵是一种特殊的矩阵，其中大多数元素为零，而非零元素稀疏分布在矩阵之中。为了高效地存储和操作稀疏矩阵，十字链表是一种常用的存储结构。十字链表是一种链式存储结构，每个非零...
十字链表稀疏矩阵相加
11-11
### 十字链表稀疏矩阵相加知识点详解 #### 一、背景介绍 ...通过以上内容，我们了解到在十字链表存储结构下实现稀疏矩阵相加的基本原理和技术细节。这对于理解稀疏矩阵的存储优化以及相关的算法实现非常重要。
十字链表实现稀疏矩阵的乘法
09-03
用C++编写的稀疏矩阵乘法运算，稀疏矩阵采用十字链表存储及计算
【swjtu】数据结构实验5_基于十字链表的稀疏矩阵转置
qq_52046937的博客
11-12 1050
实验内容及要求： 编写程序，从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构。其中，m、n分别表示矩阵行数和列数；i, j为非零元素行号和列号。编写算法，实现矩阵转置，输出转置后的三元组到另一字符文件中，检查你的转置结果是否正确。要求转置时不得新建元素结点(但允许新建行头/列头结点数组以及删除行头/列头结点数组，转置前后，总头结点不允许改变)。 实验目的：掌握稀疏矩阵的十字链表存储结构。 数据结构设计简要描述： 采用三元组...
十字链表计算矩阵乘积 c语言,求用十字链表实现矩阵相加算法（C语言）急！！！...
weixin_30596433的博客
05-21 183
匿名用户1级2010-02-09 回答我有一个可以用的。怎么给你？百度hi我吧。算了，我贴上来吧，由电脑编程网整理：#include#include#define smax 45typedef int datatype;typedef struct lnode //结构体和共用体的定义{int i,j;struct lnode *cptr,*rptr;union{struct lnode *ne...
数据结构-十字链表表示矩阵（C++）
Fay
05-27 1054
#ifndef CCROSS_SPARSE_H #define CCROSS_SPARSE_H /************************************************************************/ /* 以下是C++ 矩阵 类， 十字链表； /**************************************************
5.3.4 矩阵及其十字链表结构
engineer0的博客
12-19 1933
产生背景 矩阵的非零元个数和位置在操作过程中变化较大，不再适合采用顺序三元组表示。因此产生了一种用链式存储结构来表示三元组的线性表。 使用十字链表来表示矩阵 1、矩阵中每个非零元可用一个含有5个域的结点来表示：i，j，e 表示该非零元所在的行数，列数，元素值；向右域 right 用以链接同一行中下一个非零元；向下域 down 用以链接同一列中下一个非零元。 2、每个非零元同时是某个行列表或者列链表的结点，把一个矩阵转化成了一个十字交叉的链表。 3、可用两个一维数组来表示，分别存储行链表的头指针和列链..
十字链表实现矩阵存储
qq_53363981的博客
07-04 2735
一、介绍 用十字链表存储稀疏矩阵，可以起到节省空间的作用。 十字链表作为多重链表的一种，其结点分为两种： 类型1：数据域为另一个单链表的头指针。 类型2：数据域为待存储的数据。 其中，“十字”体现在：每一个存储数据的节点都属于两个单链表，从而构成十字形。 用十字链表表示的矩阵，有着以下特征： 1、整体的头指针指向最初的头结点，该头结点一般用于存储矩阵的行数、列数以及其中包含非0元素的数量。 2、由最初的头结点分别横向、纵向展开两个单链表，这两个链表中的每个结点都为类型1。 3、这两个.
C++实现基于十字链表的稀疏矩阵的转置
LW的技术小筑
04-09 4604
使用的数据结构 十字链表的定义如下: typedef struct node { int i, j;//行号，列号 int e;//存储的数据 struct node *right, *down;//right,down分别为行指针和列指针 }OLNode; 通过上述定义创建下图所示的十字链表结点: 基于十字链表存储的稀疏矩阵的创建这里不做详细讲解，这里只展示本人创建的示例: 转置算法的...
矩阵相加（十字链表）
axiqia的专栏
03-25 4728
描述 输入两个稀疏矩阵A和B，用十字链表实现A=A+B，输出它们相加的结果。   输入 第一行输入四个正整数，分别是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2，接下来的t1+t2行是三元组，分别是第一个矩阵的数据和第二个矩阵的数据, 三元组的第一个元素表示行,第二个元素表示列,第三个元素是该元素的值。   输出 输出相加后的矩阵三元组。  
经典算法题每日演练——第二十一题 十字链表
weixin_34087301的博客
04-02 1341
       上一篇我们看了矩阵的顺序存储，这篇我们再看看一种链式存储方法“十字链表”，当然目的都是一样，压缩空间。 一：概念     既然要用链表节点来模拟矩阵中的非零元素，肯定需要如下5个元素(row,col,val,down,right)，其中： row:矩阵中的行。 col:矩阵中的列。 val:矩阵中的值。 right:指向右侧的一个非零元素。 down：指向下侧的一个非...
十字链表实现稀疏矩阵加法及数据结构设计
"本文主要介绍了如何使用十字链表来实现稀疏矩阵的加法运算。实验目标是通过用户输入构建稀疏矩阵，并进行求和运算，最终以标准格式输出结果。十字链表是一种高效的存储稀疏矩阵的方式，每个非零元素对应一个节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值