十字链表法稀疏矩阵的基本操作（C语言）

已于 2023-11-18 00:35:58 修改
阅读量663 收藏 11
点赞数 9
文章标签： 链表 矩阵 c语言
于 2023-11-16 23:05:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75008697/article/details/134452351
版权

在十字链表中每一个非0元素可以用一个含5个域的结点表示，其中i,j,e分别表示非0元所在的行、列以及值
向右域right链接同一行中下一个非0元，向下域down链接同一列中下一个非0元 可用两个分别存储行列链表的头指针的一维数组表示
结构如图
在这里插入图片描述
down存放同一列中的下一个非0元的地址
right存放同一行中的下一个非0元的地址
rhead存放OLink的地址，即OLNode地址的地址
malloc rhead结构指针即分配n个OLink的地址

代码实现部分

基本操作有初始化，创建，打印，拷贝域销毁

头文件部分

需要用到的头文件以及十字链表的结构定义

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

#define ERROR 1;
#define OK 0;

typedef int Status;
typedef int ElemType;

typedef struct OLNode {
	int i, j;                      //该非0元所在行列
	ElemType e;                    //该非0元元素值
	struct OLNode* down, * right; //该非0元所在行列的后继链域
}OLNode, * OLink; //十字链表结构

typedef struct {
	OLink* rhead, * chead;   //行链表头指针，列链表头指针
	int mu, nu, tu;          //矩阵的行列与非0元个数
}CrossList;

初始化十字链表部分

创建矩阵前压迫初始化十字链表

void InitSmrix_OL(CrossList* M)//初始化十字链表
{
	M->rhead = M->chead = NULL;
	M->mu = M->nu = M->tu = 0;
}

创建十字链表函数

Status CreatSMarix_OL(CrossList* M)
{
	int i, j, k, m, n, t;
	OLNode* p, * q;
	ElemType e;
	printf("请输入矩阵的行列数和非0元个数：");
	scanf("%d %d %d", &m, &n, &t);
	M->mu = m;
	M->nu = n;
	M->tu = t;

	M->rhead = (OLink*)malloc((m + 1) * sizeof(OLink));
	if (!M->rhead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	M->chead = (OLink*)malloc((n + 1) * sizeof(OLink));
	if (!M->chead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	//初始化行列头指针
	for (k = 0; k <= m + 1; k++)
		M->rhead[k] = NULL;

	for (k = 0; k <= n + 1; k++)
		M->chead[k] = NULL;

	for (k = 0; k < t; k++)
	{
		printf("请输入非0元素所在行列与值(可任意输入)\n");
		scanf("%d %d %d", &i, &j, &e);
		p = (OLink)malloc(sizeof(OLNode));
		p->i = i; p->j = j; p->e = e;
		//开始排序
		if (M->rhead[i] == NULL || M->rhead[i]->j > p->j)
		{
			//如果这一行没有结点或者这一行的第一个结点列数大于新插入结点将这一结点插入在该行的第一个结点处
			p->right = M->rhead[i];
			M->rhead[i] = p;
		}
		else
		{
			for (q = M->rhead[i]; q->right && q->right->j < p->j; q = q->right); //寻找到p要插入的位置
			p->right = q->right;
			q->right = p;
		}
		//完成行插入
		if (M->chead[j] == NULL || M->chead[j]->i > p->i)
		{
			//如果这一列没有结点或者这一列的第一个结点的行大于新插入结点将这一结点插入在该列的第一个结点处
			p->down = M->chead[j];
			M->chead[j] = p;
		}
		else
		{
			for (q = M->chead[j]; q->down && q->down->i < p->i; q = q->down);
			//找到p列插入位置
			p->down = q->down;
			q->down = p;
		}
		//列插入完成
	}

	return OK;
}

打印稀疏矩阵函数

Status PrintSMartix(CrossList M)
{
	int i, j;
	OLNode* q;
	printf("开始遍历稀疏矩阵\n");
	
	if (!M.chead && !M.rhead)
	{
		printf("稀疏矩阵为空\n");
		return ERROR;
	}


	for (i = 1; i <= M.mu; i++)
	{
		q = M.rhead[i];
		for (j = 1; j <= M.nu; j++)
		{
			//如果此结点不为空且此结点的列数是按顺序的，打印此非0元
			if (q && q->j == j)
			{
				printf("%3d", q->e);
				q = q->right;
			}
			else
				printf("  0");
		}
		printf("\n");
	}
}

十字链表销毁函数

void DestroySMatrix(CrossList* M)
{
	int i;
	OLNode* p, * q;
	for (i = 1; i <= M->mu; i++)
	{
		p = M->rhead[i];
		while (p)
		{
			q = p;
			p = p->right;
			free(q);
		}
	}
	M->mu = M->nu = M->tu = 0;
	M->chead = M->rhead = NULL;
}

拷贝稀疏矩阵函数

拷贝的链表的链接形式虽然跟原链表一直，但他们的地址是不同的，拷贝的链表中的指针都不应该指向原链表中的结点，所以十字链表的拷贝与创建基本相同

Status CopySMartix(CrossList M, CrossList* T)
{
	int i;
	OLNode* p, * q, * r, * l;
	r = NULL;

	T->mu = M.mu;
	T->nu = M.nu;
	T->tu = M.tu;

	T->rhead = (OLink*)malloc((M.mu + 1) * sizeof(OLink));
	T->chead = (OLink*)malloc((M.nu + 1) * sizeof(OLink));
	if (!T->chead || !T->rhead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	for (i = 0; i <= T->mu; i++)
		T->rhead[i] = NULL;
	for (i = 0; i <= T->nu; i++)
		T->chead[i] = NULL;

	for (i = 1; i <= M.mu; i++)
	{
		q = M.rhead[i];
		if (!q)
			continue;
		while (q)
		{
			p = (OLink)malloc(sizeof(OLNode));
			if (!p)
				return ERROR;
			p->i = q->i;
			p->j = q->j;
			p->e = q->e;

			p->right = p->down = NULL;

			if (T->rhead[q->i] == NULL)
				T->rhead[q->i] = p;
			else
				r->right = p;
			r = p;

			if (T->chead[q->j] == NULL || T->chead[q->j]->i > q->i)
			{
				r->down = T->chead[q->j];
				T->chead[q->j] = r;
			}
			else
			{
				for (l = T->chead[q->j]; l->down && l->down->i < p->i; l = l->down);
				r->down = l->down;
				l->down = r;
			}
			q = q->right;
		}
	}

	return OK;
}

完整头文件

#define _CRT_SECURE_NO_WARNINGS 1

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

#define ERROR 1;
#define OK 0;

typedef int Status;
typedef int ElemType;

typedef struct OLNode {
	int i, j;                      //该非0元所在行列
	ElemType e;                    //该非0元元素值
	struct OLNode* down, * right; //该非0元所在行列的后继链域
}OLNode, * OLink; //十字链表结构

typedef struct {
	OLink* rhead, * chead;   //行链表头指针，列链表头指针
	int mu, nu, tu;          //矩阵的行列与非0元个数
}CrossList;


void InitSmrix_OL(CrossList* M)//初始化十字链表
{
	M->rhead = M->chead = NULL;
	M->mu = M->nu = M->tu = 0;
}

//十字链表创建稀疏矩阵
Status CreatSMarix_OL(CrossList* M)
{
	int i, j, k, m, n, t;
	OLNode* p, * q;
	ElemType e;
	printf("请输入矩阵的行列数和非0元个数：");
	scanf("%d %d %d", &m, &n, &t);
	M->mu = m;
	M->nu = n;
	M->tu = t;

	M->rhead = (OLink*)malloc((m + 1) * sizeof(OLink));
	if (!M->rhead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	M->chead = (OLink*)malloc((n + 1) * sizeof(OLink));
	if (!M->chead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	//初始化行列头指针
	for (k = 0; k <= m; k++)
		M->rhead[k] = NULL;

	for (k = 0; k <= m; k++)
		M->chead[k] = NULL;

	for (k = 0; k < t; k++)
	{
		printf("请输入非0元素所在行列与值(可任意输入)\n");
		scanf("%d %d %d", &i, &j, &e);
		p = (OLink)malloc(sizeof(OLNode));
		p->i = i; p->j = j; p->e = e;
		//开始排序
		if (M->rhead[i] == NULL || M->rhead[i]->j > p->j)
		{
			//如果这一行没有结点或者这一行的第一个结点列数大于新插入结点将这一结点插入在该行的第一个结点处
			p->right = M->rhead[i];
			M->rhead[i] = p;
		}
		else
		{
			for (q = M->rhead[i]; q->right && q->right->j < p->j; q = q->right); //寻找到p要插入的位置
			p->right = q->right;
			q->right = p;
		}
		//完成行插入
		if (M->chead[j] == NULL || M->chead[j]->i > p->i)
		{
			//如果这一列没有结点或者这一列的第一个结点的行大于新插入结点将这一结点插入在该列的第一个结点处
			p->down = M->chead[j];
			M->chead[j] = p;
		}
		else
		{
			for (q = M->chead[j]; q->down && q->down->i < p->i; q = q->down);
			//找到p列插入位置
			p->down = q->down;
			q->down = p;
		}
		//列插入完成
	}

	return OK;
}

//打印矩阵函数
Status PrintSMartix(CrossList M)
{
	int i, j;
	OLNode* q;
	printf("开始遍历稀疏矩阵\n");
	
	if (!M.chead && !M.rhead)
	{
		printf("稀疏矩阵为空\n");
		return ERROR;
	}


	for (i = 1; i <= M.mu; i++)
	{
		q = M.rhead[i];
		for (j = 1; j <= M.nu; j++)
		{
			//如果此结点不为空且此结点的列数是按顺序的，打印此非0元
			if (q && q->j == j)
			{
				printf("%3d", q->e);
				q = q->right;
			}
			else
				printf("  0");
		}
		printf("\n");
	}
}

//十字链表销毁函数 
void DestroySMatrix(CrossList* M)
{
	int i;
	OLNode* p, * q;
	for (i = 1; i <= M->mu; i++)
	{
		p = M->rhead[i];
		while (p)
		{
			q = p;
			p = p->right;
			free(q);
		}
	}
	M->mu = M->nu = M->tu = 0;
	M->chead = M->rhead = NULL;
}

//稀疏矩阵的拷贝
Status CopySMartix(CrossList M, CrossList* T)
{
	int i;
	OLNode* p, * q, * r, * l;
	r = NULL;

	T->mu = M.mu;
	T->nu = M.nu;
	T->tu = M.tu;

	T->rhead = (OLink*)malloc((M.mu + 1) * sizeof(OLink));
	T->chead = (OLink*)malloc((M.nu + 1) * sizeof(OLink));
	if (!T->chead || !T->rhead)
	{
		printf("分配内存失败\n");
		return ERROR;
	}

	for (i = 0; i <= T->mu; i++)
		T->rhead[i] = NULL;
	for (i = 0; i <= T->nu; i++)
		T->chead[i] = NULL;

	for (i = 1; i <= M.mu; i++)
	{
		q = M.rhead[i];
		if (!q)
			continue;
		while (q)
		{
			p = (OLink)malloc(sizeof(OLNode));
			if (!p)
				return ERROR;
			p->i = q->i;
			p->j = q->j;
			p->e = q->e;

			p->right = p->down = NULL;

			if (T->rhead[q->i] == NULL)
				T->rhead[q->i] = p;
			else
				r->right = p;
			r = p;

			if (T->chead[q->j] == NULL || T->chead[q->j]->i > q->i)
			{
				r->down = T->chead[q->j];
				T->chead[q->j] = r;
			}
			else
			{
				for (l = T->chead[q->j]; l->down && l->down->i < p->i; l = l->down);
				r->down = l->down;
				l->down = r;
			}
			q = q->right;
		}
	}

	return OK;
}

源函数部分

测试头文件中的函数

#include "CrossList.h"

int main()
{
	CrossList L;

	printf("测试函数CreatSMarix_OL\n");
	{
		InitSmrix_OL(&L);
		CreatSMarix_OL(&L);
		PrintSMartix(L);
	}


	printf("测试函数CopySMartix\n");
	{
		CrossList Q;
		CopySMartix(L, &Q);
		printf("复制矩阵Q为\n");
		PrintSMartix(Q);
	}

	printf("测试函数DestroySMatrix\n");
	{
		DestroySMatrix(&L);
		PrintSMartix(L);
	}
	
	return 0;
}
羊羊茶！
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
十字链表稀疏矩阵相加
11-11
### 十字链表稀疏矩阵相加知识点详解 #### 一、背景介绍 ...通过以上内容，我们了解到在十字链表存储结构下实现稀疏矩阵相加的基本原理和技术细节。这对于理解稀疏矩阵的存储优化以及相关的算法实现非常重要。
十字链表法，十字链表压缩存储稀疏矩阵详解
ZJQ的博客
08-16 3997
例如，A 和 B 分别为两个矩阵，在实现 "将矩阵 B 加到矩阵 A 上" 的操作时，矩阵 A 中的元素会发生很大的变化，之前的非 0 元素可能变为 0，而 0 元素也可能变为非 0 元素。对于此操作的实现，之前。可以看到，使用十字链表压缩存储稀疏矩阵时，矩阵中的各行各列都各用一各链表存储，与此同时，所有行链表的表头存储到一个数组（rhead），所有列链表的表头存储到另一个数组（chead）中。图 2a) 表示的是图 1 中转置之前矩阵的三元组表，2b) 表示的是图 1 中矩阵转置后对应的三元组表。
【详解】稀疏矩阵的十字链表✿◡‿◡
最新发布
2301_80035594的博客
01-12 2580
稀疏矩阵的十字链表表示，对其基本运算全部进行解释并给出代码供大家参考，超详细！！！
十字链表实现稀疏矩阵，包含十二大功能
m0_46335449的博客
11-19 2987
## 题目： 十字链表实现稀疏矩阵 1．问题描述 用十字链表存储和表示稀疏矩阵，并实现如下功能 2．基本要求 初始化：创建十字链表并从文件中读取稀疏矩阵数据（文件数据可以是三元组结构）； 在十字链表上设置坐标为（i，j）的位置值为value； 获取坐标为（i，j）的位置的值； 插入一项、删除某项的值； 输出十字链表表示的稀疏矩阵； 实现两个稀疏矩阵的加法、减法、乘法的功能，结果保存到新的十字链表中； 实现把十字链表表示的稀疏矩阵存入文件； 可以用菜单选择所有功能，设计良好的操作界面
数据结构：稀疏矩阵的十字链表存储
憧憬，思考，奋斗，飞翔
05-08 1184
//-----------------稀疏矩阵的十字链表存储------------------- #include #include using namespace std; typedef int ElemType; typedef struct CLNode { int row; int col; ElemType e; struct CLNode* right;//指向同一
数据结构——十字链表（C语言实现）
sunshion_boy的博客
11-09 7241
十字链表是将邻接表和逆邻接表结合在一起的一种有向图的数据结构 十字链表的节点结构体表示的是一个节点到另一个节点的边，并且此由指出节点（from）和指入节点（to）共同使用，因此大大节省了内存。 先直观感受一下十字链表的存储方式，观察一下规律 接下来看一下我定义的边节点的结构体，两个数据域表示from到to的边，两个指针域其实可以看做将该节点挂去何处，in_pointer就是将该节点挂在to顶点的入度链表中，out_pointer就是将该节点挂在from顶点的出度链表中 这是我定义的十字链表结构体，其中
matrix-c.zip_稀疏矩阵 十字链表
09-24
在计算机科学中，稀疏矩阵（Sparse Matrix）是一种用于存储大量零元素的矩阵数据...深入理解这个实现，可以帮助你掌握稀疏矩阵的十字链表数据结构以及C语言的链表操作技巧，这对于处理大规模稀疏数据的问题非常有用。
十字链表实现稀疏矩阵 （自己设计，可用）
10-26
稀疏矩阵是一种优化存储...总之，这个项目展示了如何使用十字链表和uthash库来高效地处理稀疏矩阵，实现其基本操作。理解这一实现对于深入学习数据结构和算法，特别是在处理大量零元素的数据集时，具有重要的实际意义。
matrix 基于十字链表的稀疏矩阵 C语言
09-19
接下来，我们需要设计一系列操作函数来实现稀疏矩阵的基本操作： 1. `init_matrix()`：初始化空的十字链表稀疏矩阵。 2. `insert_element(int row, int col, int value)`：向矩阵中插入一个非零元素。 3. `delete_...
采用十字链表表示稀疏矩阵，并实现矩阵的加法运算
10-29
十字链表是一种常用的数据结构，用来表示稀疏矩阵。在本文中，我们将讨论如何使用十字链表表示稀疏矩阵，并实现矩阵的加法运算。 一、十字链表的定义 十字链表是一种特殊的链表结构，每个结点都有两个指针，分别...
C语言实现十字链表
07-25
在c语言的学习中，链表是十分重要的。当我们需要编写一些结构比较复杂的程序时，十字链表就凸显出其重要的作用了。
图的十字链表C语言源码
01-01
图的十字链表C语言实现
图的十字链表代码(C语言)
09-06
数据结构C语言版里的图十字链表算法实现，代码里有详细注释
C语言实现十字链表 数据结构
06-03
C语言实现十字链表 C语言实现十字链表 C语言实现十字链表
C语言版是十字链表
12-06
C语言版是十字链表 数据结构上机中用到的 很好用的
【数据结构】十字链表完全实现（C语言）
weixin_46101687的博客
11-04 513
【数据结构】十字链表完全实现（C语言） #include <stdio.h> #include <stdlib.h> #include <string.h> #define MaxNum 20 typedef int Status; typedef int InfoType; typedef char VertexType; //弧结点结构体 typedef struct ArcBox{ int tailVex,headVex; struct Arc
C语言数据结构、十字链表的分析及实现
ZER00000001的博客
06-16 4608
结在上篇文章的最后，我们分析了邻接表的优劣，邻接表本身并没有什么大的缺陷，如果说有缺点，那么是对于有向图而言对同时表示一个顶点的出度和入度麻烦，因为需要有邻接表和逆邻接表同时表示，而且这种应用场景是存在的。十字链表就是为了使这个问题得到解决而出现的。所以十字链表就是一种将邻接表和逆邻接表结合在一起的一种图的存储结构，它针对的就是有向图中出度和入度一起使用的情况，并且大大节省了内存。十字链表是由数............
数据结构——十字链表法（C语言实现）
qq_27846147的博客
06-07 1212
数据结构——十字链表法（C语言实现） 直接上代码 //十字链表 十字链表只能存储有向图 #include "stdio.h" #include "stdlib.h" #define max 100 //弧结点 typedef struct ArcBox { int headvex, tailvex; //起点和终点在顺序表中的索引 struct ArcBox *hlink, *tlink; //起点或终点相同的弧 // int info; //权 }ArcBox; //顶点结点
c语言数据结构---十字链表
2202_75787160的博客
11-14 191
【代码】c语言数据结构---十字链表。
十字链表实现两个稀疏矩阵相加的C语言代码
04-24
下面是十字链表实现两个稀疏矩阵相加的C语言代码： ``` #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 1000 typedef int Status; typedef struct OLNode ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值