用三列二维数组表示的稀疏矩阵类

最新推荐文章于 2022-11-05 23:49:28 发布
最新推荐文章于 2022-11-05 23:49:28 发布
阅读量8.6k 收藏 13
点赞数 1
分类专栏： c.c++.数据结构 文章标签： bt class delete 存储 c system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xumin07061133/article/details/7871984
版权

1.稀疏矩阵：矩阵中绝大多数的元素值为零，只有少数的非零元素值；

2.对稀疏矩阵采用压缩存储的目的是为了节省存储空间，并且，稀疏矩阵压缩存储后，还要能够比较方便地访问其中的没个元素（包括零元素和非零元素）；

3.对稀疏矩阵进行压缩存储有两种方法：稀疏矩阵的三列二维数组表示和十字链表方法。

稀疏矩阵的三列二维数组表示：

    （1）每个非零元素用三元组表示：（i，j，v）分别对应（行，列，非零元素）；

    （2） 为了表示唯一性，除了每个非零元素用一个三元组表示外，在所有的非零元素三元组之前添加一组信息（I，J，V）对应（总行数，总列数，非零元素个数），也就是说，我们要确定确切的稀疏矩阵，必须先知道该稀疏矩阵的总行数，总列数，非零个数；

    （3）为了便于在三列二维数组B中访问稀疏矩阵A中的各元素，通常还附设两个长度与稀疏矩阵A的行数相同的向量POS与NUM。其中POS[K]表示稀疏矩阵A中的第k行的第一个非零元素（如果有的话）在三列二维组B中的行号；NUM[k]表示稀疏矩阵A中第k行中非零元素的个数；

pos[0]=0; pos[k]=pos[k-1]+num[k-1]

4.三列二维数组表示的稀疏矩阵类如下:

文件名：X_Array.h

#include <iostream>
#include <iomanip>
using namespace std;
template <class T>
struct B
{
	int i;   //非零元素所在行号
	int j;   //非零元素所在列号
	T v;     //非零元素值
};
//三列二维数组表示的稀疏矩阵类
template <class T>
class X_Array
{
private:
	int mm;      //稀疏矩阵行数
	int nn;      //稀疏矩阵列数
	int tt;      //非零个数
	B<T> *bb;    //三列二维数组空间
	int *pos;    //某行第一个非零元素在b中的下标
	int *num;    //某行非零元素的个数
public:
	void in_X_Array();                    // 以三元组形式键盘输入稀

	
	void cp_X_Array(int,int,int,B<T>[]);  // 复制三元数组
	void th_X_Array(int,int,T[]);         // 由一般稀疏矩阵转换
	void prt_X_Array();                   // 按行输出稀疏矩阵
	X_Array tran_X_Array();               // 稀疏矩阵转置
	X_Array operator +(X_Array &);        // 稀疏矩阵相加
	X_Array operator *(X_Array &);        // 稀疏矩阵相乘


};

// 以三元组形式键盘输入稀疏矩阵非零元素

template <class T>
void X_Array<T>::in_X_Array()
{
	int k,m,n;
	cout<<"输入行数 列数 非零元素个数："<<endl;
	cin>>mm>>nn>>tt;
	bb=new B<T>[tt];
	cout<<"输入行号 列号 非零元素值:"<<endl;
	for(k=0;k<tt;k++)
	{
		cin>>m>>n>>bb[k].v;
		bb[k].i=m-1;
		bb[k].j=n-1;
	}
	pos=new int[mm];
	num=new int[mm];
	for(k=0;k<mm;k++)  //num向量初始化
		num[k]=0;      //初始化mm行的每行num都设为零
	for(k=0;k<tt;k++)
		num[bb[k].i]=num[bb[k].i]+1;  //提取每个非零元素的行号，出现行号的数组num值加1，当n个非零元素在同一行时，则加n次。
		pos[0]=0;
	for(k=1;k<mm;k++)       //构造pos向量
		pos[k]=pos[k-1]+num[k-1];  //pos[k]表示在稀疏矩阵第k行中第一个非零元素在数组B中的行号
		return;
}

//复制三元数组
template <class T>
void X_Array<T>::cp_X_Array(int m,int n,int t,B<T> b[])
{
	int k;
	mm=m;
	nn=n;
	tt=t;
	bb=new B<T>[tt];
	for(k=0;k<tt;k++)
	{
		bb[k].i=b[k].i-1;
		bb[k].j=b[k].j-1;
		bb[k].v=b[k].v;
	}
	pos=new int[mm];
	num=new int[mm];
	for(k=0;k<mm;k++)  //num向量初始化
		num[k]=0;      //初始化mm行的每行num都设为零
	for(k=0;k<tt;k++)
		num[bb[k].i]=num[bb[k].i]+1;  //提取每个非零元素的行号，出现行号的数组num值加1，当n个非零元素在同一行时，则加n次。
		pos[0]=0;
	for(k=1;k<mm;k++)       //构造pos向量
		pos[k]=pos[k-1]+num[k-1];  //pos[k]表示在稀疏矩阵第k行中第一个非零元素在数组B中的行号
		return;

}
// 由一般稀疏矩阵转换
template <class T>
void X_Array<T>::th_X_Array(int m,int n,T a[])
{
	int k,t=0,p,q;
	T d;
	for(k=0;k<m*n;k++)          //统计非零个数
		if(a[k]!=0) t++;  
	mm=m;nn=n;tt=t;
	bb=new B<T>[tt];
	k=0;
	for(p=0;p<m;p++)
		for(q=0;q<n;q++)
		{
			d=a[p*n+q];
			if(d!=0)             //非零元素
			{
				bb[k].i=p;
				bb[k].j=q;
				bb[k].v=d;
				k=k+1;
			}
		}
		pos=new int[mm];
		num=new int[mm];
		for(k=0;k<mm;k++)  //num向量初始化
			num[k]=0;      //初始化mm行的每行num都设为零
		for(k=0;k<tt;k++)
			num[bb[k].i]=num[bb[k].i]+1;  //提取每个非零元素的行号，出现行号的数组num值加1，当n个非零元素在同一行时，则加n次。
			pos[0]=0;
		for(k=1;k<mm;k++)       //构造pos向量
			pos[k]=pos[k-1]+num[k-1];  //pos[k]表示在稀疏矩阵第k行中第一个非零元素在数组B中的行号
			return;

}
// 按行输出稀疏矩阵
template <class T>
void X_Array<T>::prt_X_Array()
{
	int k,kk,p;
	for(k=0;k<mm;k++)                         //按行输出
	{
		p=pos[k];
		for(kk=0;kk<nn;kk++)                  //输出一行
			if((bb[p].i==k)&&(bb[p].j==kk))   //输出非零元素
			{
				cout<<setw(8)<<bb[p].v;p=p+1;
			}
			else
				cout<<setw(8)<<0;
		cout<<endl;
	}
	return;

}
// 稀疏矩阵转置
template <class T>
X_Array<T> X_Array<T>::tran_X_Array()
{
	X_Array<T> at;                                 //定义转置矩阵对象
	int k,p,q;
	at.mm=nn;
	at.nn=mm;
	at.tt=tt;
	at.bb=new B<T>[tt];
	k=0;
	for(p=0;p<nn;p++)                              //按列扫描所有非零元素
		for(q=0;q<tt;q++)
		{
			if(bb[q].j==p)                         //  将非零元素一次存放到转置矩阵的三列二维数组中               
			{
				at.bb[k].i=bb[q].j;
				at.bb[k].j=bb[q].i;
				at.bb[k].v=bb[q].v;
				k++;
			}
		}
		at.pos=new int[at.mm];
		at.num=new int[at.mm];
		for(k=0;k<at.mm;k++)
			at.num[k]=0;
		for(k=0;k<at.tt;k++)
			at.num[at.bb[k].i]=at.num[at.bb[k].i]+1;
		at.pos[0]=0;
		for(k=1;k<at.mm;k++)
			at.pos[k]=at.pos[k-1]+at.num[k-1];
		return (at);                                      //返回转置矩阵
}

// 稀疏矩阵相加
template <class T>
X_Array<T> X_Array<T>::operator+ (X_Array<T> &b)
{
	X_Array<T> c;
	B<T> *a;
	T d;
	int m,n,k,p;
	if((mm!=b.mm)||(nn!=b.nn))
		cout<<"不能相加！"<<endl;
	else
	{
		a=new B<T>[tt+b.tt];                         //临时申请一个三列二维数组空间
		p=0;
		for(k=0;k<mm;k++)                            //逐行处理
		{
			m=pos[k];n=b.pos[k];
			while((bb[m].i==k)&&(b.bb[n].i==k))        //行号相同
			{
				if(bb[m].j==b.bb[n].j)                 //列号相同则相加
				{
					d=bb[m].v+b.bb[n].v;
					if(d!=0)                           //相加后非零
					{
						a[p].i=k;a[p].j=bb[m].j;
						a[p].v=d;p=p+1;
					}
					m=m+1;n=n+1;
				}
				else if(bb[m].j<b.bb[n].j)            //列号不同则复制列号小的一项
				{
					a[p].i=k;a[p].j=bb[m].j;
					a[p].v=bb[m].v;p=p+1;
					m=m+1;

				}
				else                                 //列号不同复制另一项
				{
					a[p].i=k;a[p].j=b.bb[m].j;
					a[p].v=b.bb[m].v;p=p+1;
					n=n+1;

				}
			}
			while(bb[m].i==k)                       //复制矩阵中本行剩余的非零元素
			{
				a[p].i=k;a[p].j=bb[m].j;
				a[p].v=bb[m].v;p=p+1;
				m=m+1;

			}
			while(b.bb[n].i==k)                    //复制另一矩阵中本行剩余的非零元素
			{
				a[p].i=k;a[p].j=b.bb[m].j;
				a[p].v=b.bb[m].v;p=p+1;
				n=n+1;

			}
		}
		c.mm=mm;c.nn=nn;c.tt=p;
		c.bb=new B<T>[p];                          //申请一个三列二维数组空间
		for(k=0;k<p;k++)                           //复制临时三列二维数组空间中的元素
		{
			c.bb[k].i=a[k].i;
			c.bb[k].j=a[k].j;
			c.bb[k].v=a[k].v;
		}
		delete a;                                    //释放临时三列二维数组空间
		c.pos=new int[c.mm];
		c.num=new int[c.mm];
		for(k=0;k<c.mm;k++)
			c.num[k]=0;
		for(k=0;k<c.tt;k++)
			c.num[c.bb[k].i]=c.num[c.bb[k].i]+1;
		c.pos[0]=0;
		for(k=1;k<c.mm;k++)
			c.pos[k]=c.pos[k-1]+c.num[k-1];

	}
	return c;
}
template <class T>
X_Array<T> X_Array<T>::operator* (X_Array<T> &b)
{
	X_Array<T> cc;
	int k,m,n,p,t;
	T *c;                  //定义乘积矩阵
	if(nn!=b.mm)
		cout<<"两矩阵无法相乘!"<<endl;
	else
	{
		c=new T[mm*b.nn];  //申请乘积矩阵的临时空间
		k=0;
		for(m=0;m<mm;m++)     
		{
			for(n=0;n<b.nn;n++)
			{
				c[k]=0;k=k+1;  //乘积矩阵元素初始化为零
			}
		}
		for(m=0;m<tt;m++)     //对于左矩阵中的每一个非零元素
		{
			k=bb[m].j;        //左矩阵中非零元素的列值K
			n=b.pos[k];       //右矩阵中行号与K相同的第一个非零元素的位置
			t=b.pos[k]+b.num[k];//右矩阵中行号与k相同的最后一个非零元素的位置
			while(n!=t)
			{
				p=bb[m].i*b.nn+b.bb[n].j;//在乘积矩阵中的位置
				c[p]=c[p]+bb[m].v*b.bb[n].v;//累加非零元素的乘积
				n=n+1;
			}

		}
		cc.th_X_Array(mm,b.nn,c); //由一般的稀疏矩阵转换成用三列二维数组表示
		delete c;                 //释放乘积矩阵的临时空间
	}
	return cc;
}



2.实例应用：

#include "test2.h"
#include<stdlib.h>
int main()
{
	B<double> a[8]={{1,3,3.0},{1,8,1.0},{3,1,9.0},{4,5,7.0},{5,7,6.0},{6,4,2.0},{6,6,3.0},{7,3,5.0}};
	X_Array<double> x,y,z,xt,c;
	x.cp_X_Array(7,8,8,a);
	cout<<"输出稀疏矩阵X："<<endl;
	x.prt_X_Array();
	xt=x.tran_X_Array();

	cout<<"输出稀疏矩阵x的转置xt："<<endl;
	xt.prt_X_Array();
	y.in_X_Array();
	cout<<"输出稀疏矩阵y："<<endl;
	y.prt_X_Array();
	z=x+y;
	cout<<"输出稀疏矩阵z=x+y"<<endl;
	z.prt_X_Array();
	c=x*xt;
	cout<<"输出稀疏矩阵c=x*y"<<endl;
	c.prt_X_Array();
	system("pause");
	return 0;
}


3.实验结果：

 

 

小许
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
稀疏矩阵的表示以及转置
qq_44103359的博客
05-11 422
稀疏矩阵是一种在很多元素为零的矩阵，它通常用于科学计算和工程领域。在稀疏矩阵中，非零元素的数目远远小于零元素的数目。由于这个特性，稀疏矩阵的表示和操作与传统矩阵不同，旨在减少内存使用和提高计算效率。
基于一维数组的c# 矩阵类源码
07-14
对于矩阵，我们通常使用二维数组表示，但在某些情况下，使用一维数组可以提高内存效率和计算速度。这是因为一维数组的连续存储特性有利于内存管理和缓存优化。 要创建一个基于一维数组的C#矩阵类，我们需要定义以下...
稀疏矩阵表示
04-05
稀疏矩阵的表示 三列两维数组表示法 十字链表表示法
稀疏数组
希冀
02-27 221
实际需求 基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来该数组。 稀疏数组的处理方法时： 稀疏数组第一行记录数组一共有几行几列，有多少个不同的值。 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。而这个小规模的数组就称为稀疏数组。 二维数组转稀疏数组的思路 遍历原始的二维数组，得到有效数据的个数sum 根据sum就可以创...
二维数组转换稀疏矩阵
weixin_44695702的博客
11-05 509
二维数组转换稀疏矩阵 例子: package com.bei.spaceArray; /** * @Auther: HoneySky * @Date: 2020/11/5 10:32 */ public class spaceArray { public static void main(String[] args) { //定义一个二维矩阵 //0表示没有棋子 1表示黑子 2表示白子 int [][] chessArr=new int[1
数组（稀疏矩阵）
lumaomao_的专栏
01-28 723
typedef struct { int i,j; int value; }Triple; typedef struct { Triple data[MAXSIZE]; int rpos[MAXRC]; int row,col,num; }XiShuArray; int triarray(XiShuArray &M) // 创建一个稀疏矩阵； // 输入行数、列数
001 二维数组与稀疏矩阵
want_to_future的博客
07-07 513
001 二维数组与稀疏矩阵实际问题假如有这样的二维数组转化为稀疏矩阵转化过程Java代码总结 实际问题 棋牌游戏，比如五子棋，这类游戏有一个游戏存档的功能。将棋子以二维数组形式进行存放，0代表无子，1代表白子，2代表黑子。这样解决了棋子的存放，但是可能存在大量无效数据浪费空间，稀疏矩阵可以解决这一问题。 假如有这样的二维数组 转化为稀疏矩阵 转化过程 第一步：找到二维数组内有多少有效元素（不为0的数）、二维数组的大小 第二步：二维数组的行作为稀疏矩阵的第一行第一个，二维数组的列作为稀疏矩阵的第一行第二个
MATLAB数计算功能(向量、矩阵、数组、稀疏矩阵).zip
最新发布
09-02
矩阵是二维数组，是MATLAB的核心概念，因为它的运算遵循线性代数规则。矩阵的乘法、转置、逆和求行列式等操作是MATLAB中的基础功能。例如，`A*B`表示矩阵乘法，`A.'`表示转置，`inv(A)`计算逆矩阵，`det(A)`返回矩阵...
实验四 二维数组基本操作的编程实现
02-09
二维数组基本操作的编程实现 要求： 二维数组基本操作的编程实现（2学时，验证型），掌握数组的建立、读取数据、压缩存储等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。也鼓励...
数据结构：第5章 数组和稀疏矩阵.ppt
06-12
对于二维数组，计算机的存储结构是线性的，需要用行／列次序排放方式来存储元素。以行序为主序的存储方式，二维数组的线性排列次序为：a1,1,a1,2,…,a1,n, a2,1,a2,2,…,a2,n , …, am,1,am,2,…am,n。对于一个已知...
数据结构数组和稀疏矩阵PPT学习教案.pptx
10-08
例如，二维数组的存储结构可以使用行优先顺序存储结构，即a11, a12, …, a1n, a21, a22, …, amn。 六、数组的存储地址计算 数组的存储地址可以通过公式LOC(aij) = LOC(a11) + [(i-1)*n + j-1]*d计算得到，其中LOC...
设稀疏矩阵 M(m,n)存放于二维数组 A[m][n]中，设计一个算法，从 A 生成系 数矩阵的 M 的三元组表示。
weixin_45963815的博客
04-24 1066
设稀疏矩阵 M(m,n)存放于二维数组 A[m][n]中，设计一个算法，从 A 生成系 数矩阵的 M 的三元组表示。 源代码： #include<stdio.h> #include<stdlib.h> #define OK 1 #define MAXSIZE 12500 typedef int Status; typedef int ElemType; Status Cre...
稀疏矩阵
黑手日志
10-20 223
稀疏矩阵 数据结构 稀疏矩阵 基本概念 压缩存储 转置、输出操作 基本概念 在一个mn的矩阵中有x个非零元素，若c=x/(mn)<0.05，则称矩阵为稀疏矩阵 压缩存储 存储矩阵只需要存储非零元素（这样大大节省了物理空间）。 定义一个结构体，存储数组的行数，列数，非零元素个数，以及存储各个非零元素（利用data数组实现）。data数组的每个储存空间内，存储非零元素的行标，列标（本博客从0...
稀疏矩阵的简单描述
goodman_lqifei的博客
08-30 1899
稀疏矩阵 设矩阵A中有s个非零元素，若s远远小于矩阵元素的总数（即s≦m×n），则称A为稀疏矩阵 由于非零元素的分布一般是没有规律的，因此在存储非零元素的同时，必须同时记下它所在的行和列的位置（i,j)。所以，一个三元组(i,j,aij)唯一确定了矩阵A的一个非零元。因此，稀疏矩阵可由表示非零元的三元组及其行列数唯一确定。 一、三元组顺序表     假设以顺序存储结构来表示三元组表，则可得
稀疏矩阵的基本运算
09-03 5669
前记：这一章课件里主要讲了数组和广义表的属性和一些常用的操作。下面针对稀疏矩阵的基本操作做一个具体的实现，大家在运用中可以参考。题目描述：实现一个能进行稀疏矩阵基本运算的运算器，包括相加、相减、相乘。include<time.h>/*用于下面的srand((unsigned)time(NULL));函数的头文件*/ #include<stdio.h> #includ...
JAVA版本的稀疏数组
weixin_42026631的博客
07-22 127
稀疏数组的核心思想是把无意义的数据去掉，只保留有用的数据，实现压缩的效果 举例 用一行来表示行和列和有多少有效数据，其他用来表示该有效数据的位置 二维数组转为稀疏数组的思路 1.遍历原始的二维数组，得到有效数据的个数SUM 2.根据SUM就可以创建稀疏数组sparseArr int[sum+1][3] 3.将二维数组的有效数据存入稀疏数组 -------------------------------------------------------------- 稀疏数组转为原始二维数组的思路 1.先读
稀疏矩阵的基础
m0_63783532的博客
11-05 1255
稀疏矩阵的基础，稀疏矩阵的转置，稀疏矩阵的三元组，稀疏矩阵的十字链表
第5章数组与广义表1
08-04
然而，对于某些特殊矩阵（如稀疏矩阵），直接使用二维数组存储会导致大量空间浪费，因此需要采用压缩存储技术，如链表或稀疏矩阵的三元组表示法，以提高存储效率。 广义表作为线性表的扩展，是一种更通用的数据结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值