数据结构实验5

矩阵的加法、乘法计算

创建 稀疏矩阵类 ,采用行主顺序把稀疏矩阵非0元素映射到一维数组中,提供操作:两个稀疏矩阵相加、两个稀疏矩阵相乘、输出矩阵。
键盘输入矩阵的行数、列数;并按行优先顺序输入矩阵的各元素值,建立矩阵;
对建立的矩阵执行相加、相乘的操作,输出操作的结果矩阵。
操作描述
为方便操作描述,我们假设存在一个矩阵P,下列各操作实际为对矩阵P的操作。
重置矩阵:
1
矩阵的行数n 矩阵的列数m
[n行m列 表示矩阵中的所有元素]
即重置矩阵P的尺寸为n行m列,且随后按行优先顺序输入矩阵P的各个元素。
矩阵乘法:
2
矩阵的行数 矩阵的列数
[n行m列 表示矩阵中的所有元素]
设输入的矩阵为Q,若PxQ运算合法,则将PxQ的结果矩阵赋给P,若不合法,则将Q赋给P,同时输出-1。
矩阵加法:
3
矩阵的行数 矩阵的列数
[n行m列 表示矩阵中的所有元素]
设输入的矩阵为Q,若P+Q运算合法,则将P+Q的结果矩阵赋给P,若不合法,则将Q赋给P,同时输出-1。
输出操作:
4
设当前矩阵P的尺寸为n行m列,第一行输出矩阵P的行数和列数，随后n行按行优先顺序输出矩阵P,每行m个数字,来表示当前的矩阵内容，每行数字之间用空格分隔。
输入格式
第一行一个w(1<=w<=40)代表操作个数，接下来若干行是各个操作,其中保证第一个操作一定为重置矩阵。
输出格式
当执行操作4时,输出矩阵P;当执行操作2或3时,若对应运算不合法,则输出-1。
Sample Input
5
1
3 3
3 4 0
0 2 1
4 1 1
2
2 3
4 1 1
2 2 3
4
3
2 3
1 2 3
2 2 3
4
Sample Output
-1
2 3
4 1 1
2 2 3
2 3
5 3 4
4 4 6
限制
矩阵的行数n与列数m一定为整数,且1<=n,m<=40。
1s, 64MB for each test case。

#include<iostream>
using namespace std;
const long long int maxsz=9999999;
template<class T>
struct triple{
	int row,col;
	T value;
	triple& operator=(triple& x){
		row=x.row;
		col=x.col;
		value=x.value;
		return *this;
	}
};
template<class T>
class sparseMatrix{
	private:
		int rows;//行 
		int cols;//列 
		int terms;//非零元素个数
		triple<T>* tArray;//用来存value的数组  
	public:
		~sparseMatrix(){delete[] tArray;};//析构函数 
		sparseMatrix(int &m,int &n);//构造函数 
		void change(int m,int n);
		void sparseMatrix1(sparseMatrix& a);//复制函数
		void input();//重置1 
		int multiply(sparseMatrix<T> &b);//乘法2 
      	int add(sparseMatrix<T> &b);//加法3 
		void output();//输出4 
};
//构造函数 ,初始化 
template<class T>
sparseMatrix<T>::sparseMatrix(int &m,int &n)
{
	rows=m;cols=n;
	terms=0;
	tArray=new triple<T> [maxsz];
}
template<class T>
void sparseMatrix<T>::change(int m,int n)
{
	rows=m;
	cols=n;
	}
template<class T>
void sparseMatrix<T>::sparseMatrix1(sparseMatrix& a)
{
	rows=a.rows;      //赋值矩阵的性质
	cols=a.cols;
	terms=a.terms;
	for(int i=0;i<terms;i++){
		tArray[i].row=a.tArray[i].row;
		tArray[i].col=a.tArray[i].col;
		tArray[i].value=a.tArray[i].value;	
	}
}
//重置矩阵1
template<class T>
void sparseMatrix<T>::input()
{
	T elem;terms=0;
	for(int i=0;i<rows*cols;i++)
	{
		cin>>elem;
		if(elem!=0){
			tArray[terms].value=elem;
			tArray[terms].col=i-(i/cols)*cols+1;
			tArray[terms].row=i/cols+1;
			terms++;
		}
	}
	/*if(terms==0){
		tArray[terms].row=1;
		tArray[terms].col=1;
		tArray[terms].value=0;
		terms=1;
	}*/
	   
}
//乘法
template<class T>
int sparseMatrix<T>::multiply(sparseMatrix<T> &b)
{
	if(cols!=b.rows){
		sparseMatrix1(b);
		return -1;
	}
	else{
		sparseMatrix<T> c(rows,b.cols);
		T* tag=new T[b.cols+1];
		for(int i=0;i<b.cols+1;i++)
			tag[i]=0;
		for(int j=0;j<terms;j++)
		{
			for(int k=0;k<b.terms;k++)
				if(tArray[j].col==b.tArray[k].row)
					tag[b.tArray[k].col]+=tArray[j].value*b.tArray[k].value;
//分析知道↑，当被乘数的列==乘数的行时，两个数可相乘，且不为0 
			if((j<terms-1&&tArray[j].row!=tArray[j+1].row)||j==terms-1)
			{
				for (int h = 1; h < b.cols+1; h++)
				{
					if (tag[h] != 0)
					{
						c.tArray[c.terms].row = tArray[j].row;
						c.tArray[c.terms].col = h;
				   	 	c.tArray[c.terms].value= tag[h];
						tag[h] = 0;
						c.terms++;
					}
				}
			}
		}	
		sparseMatrix1(c);
		return 0;
	}
}
//加法3
template<class T>
int sparseMatrix<T>::add(sparseMatrix<T>& b)
{
	if(rows!=b.rows || cols !=b.cols)
	{
		sparseMatrix1(b);
		return -1;
	}
	else{//设置结果矩阵的特征 
		sparseMatrix<T> c(rows,cols);
		int it=0,ib=0;	
		while(it!=terms && ib !=b.terms){
			 int tIndex=(tArray[it]).row*cols+(tArray[it]).col;
			 int bIndex=b.tArray[ib].row*cols+(b.tArray[ib]).col;
			if(tIndex<bIndex)
			{
				c.tArray[c.terms].col=tArray[it].col;
				c.tArray[c.terms].row=tArray[it].row;
				c.tArray[c.terms].value=tArray[it].value;
				it++;c.terms++;
			}	
			else {
			if(tIndex==bIndex){
				if((tArray[it]).value+(b.tArray[ib]).value!=0)
				{
					c.tArray[c.terms].col=(tArray[it]).col;
					c.tArray[c.terms].row=(tArray[it]).row;
					c.tArray[c.terms].value=(tArray[it]).value+(b.tArray[ib]).value;
					c.terms++;
				}
				it++;ib++;
			}	//
			else 
				{
					c.tArray[c.terms].col=b.tArray[ib].col;
					c.tArray[c.terms].row=b.tArray[ib].row;
					c.tArray[c.terms].value=b.tArray[ib].value;
					ib++;c.terms++;
				}
		}
	}
	//复制剩余项
	for(;it != terms;it++)
	{
		c.tArray[c.terms].col=tArray[it].col;
		c.tArray[c.terms].row=tArray[it].row;
		c.tArray[c.terms].value=tArray[it].value;
		c.terms++;
		}
	for(;ib !=b.terms;ib++)
	{
		c.tArray[c.terms].col=b.tArray[ib].col;
		c.tArray[c.terms].row=b.tArray[ib].row;
		c.tArray[c.terms].value=b.tArray[ib].value;
		c.terms++;
		}
	sparseMatrix1(c);
	return 0;	
	}
}
template<class T>
void sparseMatrix<T>::output()
{
	int k=0;
	cout<<rows<<" "<<cols<<endl;
	for(int i=0;i<rows;i++)
	{
		for(int j=0;j<cols;j++)
		{
			if(k<terms && tArray[k].row==i+1 && tArray[k].col==j+1)
					cout<<tArray[k++].value<<" ";
			else
				cout<<0<<" ";
		}
		cout<<endl;
	}
}
int main()
{
	int w,x,deci=0,m=0,n=0;
	sparseMatrix<int> sm(m,n);
	cin>>w;
	for(int i=0;i<w;i++){
		cin>>x;
		if(x==1)//输入 
		{
			cin>>m>>n;
			sm.change(m,n);
			sm.input();}
		else if(x==2)//乘法
			{
			cin>>m>>n;
			sparseMatrix<int> a(m,n);
			a.input();
			deci=sm.multiply(a);
			if(deci==-1)
				cout<<deci<<endl;;
		}
		else if(x==3)//加法
			{
			cin>>m>>n;
			sparseMatrix<int> b(m,n);
			b.input();
			deci=sm.add(b);
			if(deci==-1)
				cout<<deci<<endl;
		}
		else//输出
			sm.output();
	}
	return 0; 
}

这里矩阵乘法按照列计算的，若要降低算法的复杂度，乘法需要改变为按行计算，也即是被乘数的行。