C++数据结构稀疏矩阵运算(含加减乘及快速转置)

这篇具有很好参考价值的文章主要介绍了C++数据结构稀疏矩阵运算(含加减乘及快速转置)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

题目:

内容:稀疏矩阵运算器

要求:使用三元组顺序表存储矩阵;实现矩阵的逆置、加、减、乘运算;具有相应的报错处理。

本人采用C++来书写该数据结构的题目,有兴趣的同学可以了解一下需要掌握一定的封装的能力。

类的结果存储如下所示:

class ju{
	struct shu{
		int i,j;
		int x;
	};
	int m,n;
	int len;
	shu a[25];
	public:
		int juzhen[10][10];    //矩阵内容的存储
		ju(int o,int p);    //矩阵的初始化赋值
		void print()const;
		void generate();    //保存转置后的矩阵
		void get_three();    //获得计算结束的三元组
		int get_m()const;    
		int get_n()const;
		ju Invert(ju y,ju c);    //转置函数
		ju& add(ju c,ju &y);    //矩阵加法
		ju& minus(ju c,ju &y);    //矩阵减法
		ju& multi(ju c,ju &y);    //矩阵乘法
};

加减法的函数内容如下所示:

 其中的运算最容易实现的就是加减法,本人采取类成员函数的方式来进行计算,使用一个类的引用使其可以在函数体内部对其本身进行修改返回一个引用值可以避免程序开辟一个临时变量来浪费内存。具体的实现内容则是进行循环将其相应位置进行加减法的运算即可

ju & ju::add(ju c,ju &y) 
{
	int m1,n1;
	m1=c.get_m();
	n1=c.get_n();
	if(m!=m1||n!=n1){
		cout<<"您输入的矩阵格式不匹配\n";
		return *this;
	} 
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			y.juzhen[i][j]=juzhen[i][j]+c.juzhen[i][j];
		}
	}
	return y;
}

ju & ju::minus(ju c,ju &y)
{
	int m1,n1;
	m1=c.get_m();
	n1=c.get_n();
	if(m!=m1||n!=n1){
		cout<<"您输入的矩阵格式不匹配\n";
		return *this;
	} 
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			y.juzhen[i][j]=juzhen[i][j]-c.juzhen[i][j];
		}
	}
	return y;
} 

乘法的函数如下:

该函数实现的功能是矩阵的乘法,我们在线性代数中学习到的只有当前一项的列等于后一项的行时才可以进行相关的乘法,并且乘法规律则是第一行乘以第一列并且求和等于结果矩阵的1,1位置第一行乘以对应相乘第二列并且求和等于1.2位置以此类推。大家可以在纸上进行验算之后可知需要三次循环来存储结果的内容,其内容如下所示。

ju& ju::multi(ju c,ju &y)
{
	if(n!=c.m)
		cout<<"您输入的格式存在问题无法进行计算\n";
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=c.n;j++)
		{
			for(int k=1;k<=c.m;k++)
				y.juzhen[i][j]+=juzhen[i][k]*c.juzhen[k][j];
		}         
	}
	return y;
}

下来是转置并且保存结果矩阵的:

下面是稀疏矩阵的快速转置的实现,我们首先要定义两个数组来存储每一列具有多少个元素并且记录该列将转置到三元组的第几个位置,num数组则是存储一列具有多少个元素,position将记录转置到第几个位置。generate()则是获取存储该结果的矩阵。

 C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 

void ju::generate()
{
	int k,i,j;
	juzhen[10][10]={0};
	for(k=1;k<=len;k++){
		i=a[k].i;
		j=a[k].j;
		juzhen[i][j]=a[k].x;	
	}
}
ju ju::Invert(ju y,ju c)
{
	int a,b;
	int num[20],position[20];
	for(a=1;a<=c.len;a++)
	{
		num[a]=0;
		position[a]=0;		
	}
	for(a=1;a<=c.m;a++)
	{
		for(b=1;b<=c.n;b++)
		{
			if(juzhen[b][a]!=0)
			{
				num[b]++;
			}
		}
	}
	position[1]=1;
	for(a=2;a<=len;a++)
	{
		position[a]=num[a-1]+position[a-1];
	}
	for(b=1;b<=c.len;b++)
	{
		int col=c.a[b].j;
		int q=position[col];
		y.a[q].i=c.a[b].j;
		y.a[q].j=c.a[b].i;
		y.a[q].x=c.a[b].x;
		y.len++;
		y.m=c.n;
		y.n=c.m;
		++position[col];
	}
	return y;
}

整体性的代码如下所示,如果需要取走的朋友们请给个赞或者留个言谢谢

#include<iostream>
using namespace std;
int flag1=1;
int flag2=1;
int flag3=1;
class ju{
	struct shu{
		int i,j;
		int x;
	};
	int m,n;
	int len;
	shu a[25];
	public:
		int juzhen[10][10];
		ju(int o,int p);
		void print()const;
		void print1()const;
		void generate();
		void get_three();
		int get_m()const;
		int get_n()const;
		ju Invert(ju y,ju c);
		ju& add(ju c,ju &y);
		ju& minus(ju c,ju &y);
		ju& multi(ju c,ju &y);
};

void ju::get_three()
{
	int i,j;
	int k=1;
	for(i=1;i<=m;i++)
	{
		for(j=1;j<=n;j++)
		{
			if(juzhen[i][j]!=0)
			{
				len++;
				a[k].i=i;
				a[k].j=j;
				a[k].x=juzhen[i][j];
				k++;
			}
		}
	}
}

ju::ju(int o,int p)	//初始化 
{
	m=o;
	n=p;
	len=0;
	int j,i;
	cout<<"请输入矩阵各个点的数字:\n";
	for(i=1;i<=o;i++)
	{
		for(j=1;j<=p;j++)
		{
			cin>>juzhen[i][j];
		}
	}
}

int ju::get_m()const
{
	return m;
}

int ju::get_n()const
{
	return n;
}

ju & ju::add(ju c,ju &y) 
{
	int m1,n1;
	m1=c.get_m();
	n1=c.get_n();
	if(m!=m1||n!=n1){
		cout<<"您输入的矩阵格式不匹配\n";
		flag1=0;
		return *this;
	} 
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			y.juzhen[i][j]=juzhen[i][j]+c.juzhen[i][j];
		}
	}
	return y;
}

ju & ju::minus(ju c,ju &y)
{
	int m1,n1;
	m1=c.get_m();
	n1=c.get_n();
	if(m!=m1||n!=n1){
		cout<<"您输入的矩阵格式不匹配\n";
		flag2=0;
		return *this;
	} 
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			y.juzhen[i][j]=juzhen[i][j]-c.juzhen[i][j];
		}
	}
	return y;
} 

ju& ju::multi(ju c,ju &y)
{
	if(n!=c.m){
		cout<<"您输入的格式存在问题无法进行计算\n";
		flag3=0;
	}
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=c.n;j++)
		{
			for(int k=1;k<=c.m;k++)
				y.juzhen[i][j]+=juzhen[i][k]*c.juzhen[k][j];
		}         
	}
	return y;
}

void ju::print()const 	//对矩阵和三元组进行打印 
{
	cout<<"矩阵结果如下:\n";
	for(int i =1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			cout<<juzhen[i][j]<<" ";
		}
		cout<<endl;
	}
	cout<<endl;
	cout<<"上述矩阵的三元组表示如下:\n";
	for(int k=1;k<=len;k++)
	{
		cout<<a[k].i<<" "<<a[k].j<<" "<<a[k].x<<endl;
	}
}

void ju::generate()
{
	int k,i,j;
	juzhen[10][10]={0};
	for(k=1;k<=len;k++){
		i=a[k].i;
		j=a[k].j;
		juzhen[i][j]=a[k].x;	
	}
}
ju ju::Invert(ju y,ju c)
{
	int a,b;
	int num[20],position[20];
	for(a=1;a<=c.len;a++)
	{
		num[a]=0;
		position[a]=0;		
	}
	for(a=1;a<=c.m;a++)
	{
		for(b=1;b<=c.n;b++)
		{
			if(juzhen[b][a]!=0)
			{
				num[b]++;
			}
		}
	}
	position[1]=1;
	for(a=2;a<=len;a++)
	{
		position[a]=num[a-1]+position[a-1];
	}
	for(b=1;b<=c.len;b++)
	{
		int col=c.a[b].j;
		int q=position[col];
		y.a[q].i=c.a[b].j;
		y.a[q].j=c.a[b].i;
		y.a[q].x=c.a[b].x;
		y.len++;
		y.m=c.n;
		y.n=c.m;
		++position[col];
	}
	return y;
}

int main()
{
	int m1,n1,x,m2,n2;
	char c;
	cout<<"请输入第一个矩阵的格式:\n";
	cin>>m1>>n1;
	ju b(m1,n1);
	b.get_three();
	b.print();
	cout<<"请输入第二个矩阵的格式:\n";
	cin>>m2>>n2;
	ju d(m2,n2);
	d.get_three();
	cout<<"是否要进行矩阵的运算:\n";
	cin>>c;
	while(c=='y'||c=='Y')
	{
		cout<<"运算如下:"
		<<"1.矩阵加法add."
		<<"2.矩阵减法minus."
		<<"3.矩阵乘法."
		<<"4.矩阵逆置."<<endl;
		cout<<endl; 
		cout<<"请输入您要选择的运算:";
		cin>>x; 
		if(x==1){
			cout<<"请输入结果矩阵的各个元素必须定义为0\n";
			ju y(m1,n1);
			y=b.add(d,y);
			if(flag1==0)
				continue;
			y.get_three();
			cout<<"矩阵加法的结果为:\n"; 
			y.print();
		}
		else if(x==2){
			cout<<"请输入结果矩阵的各个元素必须定义为0\n";
			ju a(m1,n1);
			a=b.minus(d,a);
			if(flag2==0)
				continue;
			a.get_three();
			cout<<"矩阵减法的结果为:\n";
			a.print();
		}
		else if(x==3){
			cout<<"请输入结果矩阵的各个元素必须定义为0\n";
			ju g(m1,n2);
			g=b.multi(d,g);
			if(flag3==0)
				continue;
			g.get_three();
			cout<<"矩阵乘法的结果为:\n";
			g.print();
		}
		else if(x==4){
			ju h(m1,n1);
			h=b.Invert(h,b);
			h.generate();
			h.print();
		}
		cout<<"是否要继续进行矩阵的运算:\n";
		cin>>c;
	}
}

运行的内容结果如下:C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 C++数据结构稀疏矩阵运算(含加减乘及快速转置)

下面是一些测试错误的案例: 

C++数据结构稀疏矩阵运算(含加减乘及快速转置)

 本篇内容到此结束,有需要借走的朋友请留下点痕迹嘿嘿。文章来源地址https://www.toymoban.com/news/detail-409271.html

到了这里,关于C++数据结构稀疏矩阵运算(含加减乘及快速转置)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【开卷数据结构 】稀疏矩阵

    🌺稀疏矩阵 🍁矩阵与稀疏矩阵的定义 🌺稀疏矩阵的转置 🍁详细思路 🍀思路一 🍀思路二 🌺稀疏矩阵的乘法 🍁详细思路 Q:什么是矩阵 A: 数学上,一个 矩阵 由 m 行 n 列的元素组成,是一个 m 行,n 列的表,m 和 n 是矩阵的 维度 。一般地,写作 mxn(读作“m乘n”)来指

    2024年01月19日
    浏览(42)
  • 数据结构——稀疏矩阵

    在矩阵中,若数据为0的元素数目远远多于非0元素的数目,并且非0元素分布没有规律时,则称该矩阵为稀疏矩阵;与之相反的叫做稠密矩阵。 将棋盘看作一个二维数组,在棋子落盘时,要记录该棋子落下的坐标,其他坐标的值不做记录,默认为0。由于记录很多无意义的数据

    2024年02月03日
    浏览(41)
  • 【数据结构】数组(稀疏矩阵、特殊矩阵压缩、矩阵存储、稀疏矩阵的快速转置、十字链表)

    前几期期链接: 【数据结构】栈与队列的概念和基本操作代码实现 【数据结构】树与二叉树的概念与基本操作代码实现 k维数组的定义: k 维数组 D = { a j 1 , j 2 , . . . , j k } k维数组D={ a_{j_1, j_2, ..., j_k} } k 维数组 D = { a j 1 ​ , j 2 ​ , ... , j k ​ ​ } k 0 称为数组的维数,

    2024年04月09日
    浏览(140)
  • 【数据结构】数组和字符串(五):特殊矩阵的压缩存储:稀疏矩阵——压缩稀疏行(CSR)

    【数据结构】数组和字符串(一):矩阵的数组表示   矩阵是以按行优先次序将所有矩阵元素存放在一个一维数组中。但是对于特殊矩阵,如对称矩阵、三角矩阵、对角矩阵和稀疏矩阵等, 如果用这种方式存储,会出现大量存储空间存放重复信息或零元素的情况,这样会造

    2024年02月05日
    浏览(54)
  • 数据结构-拓展突破-特殊矩阵(对称矩阵,三角矩阵,三对角矩阵,稀疏矩阵)的压缩存储)

    对称矩阵的定义: 若n阶方阵中任意一个元素a,都有a(i,j)=a(j,i)则该矩阵为对称矩阵 也就是说对称矩阵的元素关于对角线对称。对角线上半部分称为上三角区,下半部分称为下三角区。 对称矩阵的压缩存储策略:只存储主对角线+下三角区(或主对角线+上三角区) 可以定义一维数

    2023年04月08日
    浏览(63)
  • 数据结构·练习·三元组表法实现稀疏矩阵的转置

    一、问题描述 一个mxn的矩阵A,它的转置矩阵B是一个nxm矩阵,且A[i][j]=B[j][i],0=i=m-1,0=j=n-1,即A的行是B的列,A的列是B的行。 用三元组表对稀疏矩阵进行压缩存储,再进行时间复杂度O(n)的快速转置,最后输出稀疏矩阵。 其中m=4,n=5 二、算法概述 1、问题分析 1)压缩 2)转置

    2024年02月04日
    浏览(45)
  • 西工大NOJ数据结构实验——2.1稀疏矩阵转置

    对稀疏矩阵进行转置操作,按照老师讲的,有两种办法。我用的是第一种最简单的,从上到下一行一行得走,虽然速度很慢,但是简单。 说实话这个题目很讨厌,我们定义的三元组里面mu表示的是行数,但是题目要求输入的m表示的是列数,这就很容易搞混了。 但是我们不用

    2023年04月25日
    浏览(121)
  • 【数据结构】数组和字符串(四):特殊矩阵的压缩存储:稀疏矩阵——三元组表

    【数据结构】数组和字符串(一):矩阵的数组表示   矩阵是以按行优先次序将所有矩阵元素存放在一个一维数组中。但是对于特殊矩阵,如对称矩阵、三角矩阵、对角矩阵和稀疏矩阵等, 如果用这种方式存储,会出现大量存储空间存放重复信息或零元素的情况,这样会造

    2024年02月05日
    浏览(45)
  • 数据结构 | 第七章:数组和矩阵 | 行主映射和列主映射 | 稀疏矩阵

    7.1.1 抽象数据类型 7.1.2 C++数组的索引 K维数组的索引(或下标) [ i 1 ] [ i 2 ] [ i 3 ] . . . [ i k ] [i_1][i_2][i_3]...[i_k] [ i 1 ​ ] [ i 2 ​ ] [ i 3 ​ ] ... [ i k ​ ] k维数组创建: int score [ u 1 ] [ u 2 ] [ u 3 ] . . . [ u k ] [u_1][u_2][u_3]...[u_k] [ u 1 ​ ] [ u 2 ​ ] [ u 3 ​ ] ... [ u k ​ ] ( u i u_i u i ​

    2024年01月16日
    浏览(52)
  • 【C 数据结构】以三元组表形式表示稀疏矩阵,实现两个矩阵的加法、减法

    目的:以三元组表形式表示稀疏矩阵,实现两个矩阵的加法、减法。 实验步骤 1. 定义三元组存储结构 2. 输入稀疏矩阵:首先应输入矩阵的行数、列数和非零项的数目,并判别给出的两个矩阵的行、列数对于所要求进行的运算是否匹配。可设矩阵的行数和列数均不超过20。接

    2024年02月12日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包