matrix.h

该压缩文件夹内有诸多常用算法和数据结构的c++模板编程实现

#ifndef MATRIX_H
#define MATRIX_H
#include <string>
using namespace std;
class Matrix 
{
public:
	Matrix(int m,int n)
	{
		int i=0,j=0;
		mat=new double*[m];
		for (i=0;i<m;i++)
		{
			mat[i]=new double[n];
		}
		row=m;
		column=n;
		for (i=0;i<m;i++)
		{
			for (j=0;j<n;j++)
			{
				mat[i][j]=0;
			}
		}
	}
	Matrix(double** a,int m,int n)
	{
		int i=0,j=0;
		mat=new double*[m];
		for (i=0;i<m;i++)
		{
			mat[i]=new double[n];
		}
		row=m;
		column=n;
		for (i=0;i<m;i++)
		{
			for (j=0;j<n;j++)
			{
				mat[i][j]=a[i][j];
			}
		}	
	}
	Matrix(Matrix& m2)
	{
		int i,j;
		row=m2.row;
		column=m2.column;
		mat=new double*[row];
		for (i=0;i<row;i++)
		{
			mat[i]=new double[column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				mat[i][j]=m2.getIndexOf(i,j);
			}
		}
	}
	Matrix& operator =(Matrix& m2)
	{
		int i,j;
		row=m2.row;
		column=m2.column;
		mat=new double*[row];
		for (i=0;i<row;i++)
		{
			mat[i]=new double[column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				mat[i][j]=m2.getIndexOf(i,j);
			}
		}
		return *this;
	}
	bool isPhalanx()
	{
		if (row==column)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool isSymmetic()
	{
		int i=0,j=0;
		if (!isPhalanx())
		{
			return false;
		}
		for(i=0;i<row;i++)
		{
			for (j=i+1;j<row;j++)
			{
				if (mat[i][j]!=mat[j][i])
				{
					return false;
				}
			}
		}
		return true;
	}
	double getDet()
	{
		setDet();
		return det;
	}
	int getRank()
	{
		setRank();
		return rank;
	}
	Matrix operator+(Matrix m2)
	{
		int i=0,j=0;
		if (m2.column!=column||m2.row!=row)
		{
			Matrix m(0,0);
			return m;
		}
		double** a=new double*[row];
		for (i=0;i<row;i++)
		{
			a[i]=new double[column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				a[i][j]=mat[i][j]+m2.getIndexOf(i,j);
			}
		}
		Matrix m(a,row,column);
		delete[]* a;
		return m;
	}
	Matrix operator-(Matrix m2)
	{
		int i=0,j=0;
		if (m2.column!=column||m2.row!=row)
		{
			Matrix m(0,0);
			return m;
		}
		double** a=new double*[row];
		for (i=0;i<row;i++)
		{
			a[i]=new double[column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				a[i][j]=mat[i][j]-m2.getIndexOf(i,j);
			}
		}
		Matrix m(a,row,column);
		delete[]* a;
		return m;
	}
	Matrix operator*(Matrix m2)
	{
		int i,j,k;
		if (column!=m2.row)
		{
			Matrix m(0,0);
			return m;
		}
		double** a=new double*[row];
		for (i=0;i<row;i++)
		{
			a[i]=new double[m2.column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<m2.column;j++)
			{
				a[i][j]=0;
				for (k=0;k<column;k++)
				{
					a[i][j]+=mat[i][k]*m2.getIndexOf(k,j);
				}
			}
		}
		Matrix m(a,row,m2.column);
		delete[]* a;
		return m;
	}
	bool operator ==(Matrix m2)
	{
		int i,j;
		if (row!=m2.row||column!=m2.column)
		{
			return false;
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				if (mat[i][j]!=m2.getIndexOf(i,j))
				{
					return false;
				}
			}
		}
		return true;
	}
	Matrix getMatT()
	{
		if (!isPhalanx () )
		{
			Matrix m(0,0);
			return m;
		}
		int i=0,j=0;
		double** a=new double*[row];
		for (i=0;i<row;i++)
		{
			a[i]=new double[column];
		}
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				a[i][j]=mat[j][i];
			}
		}
		Matrix m(a,row,column);
		delete[]* a;
		return m;
	}
	void translation()
	{
		int i,j;
		Matrix m=getMatT();
		delete[]* mat;
		i=row;
		row=column;
		column=i;
		mat=new double*[row];
		for (i=0;i<row;i++)
		{
			mat[i]=new double[column];
		}
		
		for (i=0;i<row;i++)
		{
			for (j=0;j<column;j++)
			{
				mat[i][j]=m.getIndexOf(i,j);
			}
		}
	}
	double getIndexOf(int m,int n)
	{
		return mat[m][n];
	}
	void setIndexOf(double d,int m,int n)
	{
		mat[m][n]=d;
	}
	double** getMatArray()
	{
		return mat;
	}
	int getRowNum()
	{
		return row;
	}
	int getColumnNum()
	{
		return column;
	}
	bool copyMatArray(double** a,int m,int n)
	{
		int i=0,j=0;
		if(m!=row||n!=column)
		{
			return false;
		}
		for (i=0;i<m;i++)
		{
			for (j=0;j<n;j++)
			{
				a[i][j]=mat[i][j];
			}
		}
		return true;
	}
	Matrix getSubMatrix(int oriRow,int oriColumn,int len,int wide)
	{
		int i,j;
		if (oriRow+wide>row||oriColumn+len>column||oriColumn<0||oriRow<0)
		{
			Matrix m(0,0);
			return m;
		}
		double** a=new double*[wide];
		for (i=0;i<wide;i++)
		{
			a[i]=new double[len];
		}
		for (i=oriRow;i<wide+oriRow;i++)
		{
			for (j=oriColumn;j<oriColumn+len;j++)
			{
				a[i-oriRow][j-oriColumn]=mat[i][j];
			}
		}
		Matrix m(a,wide,len);
		delete[]* a;
		return m;
	}
	Matrix removeRow(int r)
	{
		if (r<0||r>row-1)
		{
			Matrix m(0,0);
			return m;
		}
		int i,j,k=0;
		Matrix m(row-1,column);
		for (i=0;i<row;i++)
		{
			if (i==r)
			{
				continue;
			}
			for (j=0;j<column;j++)
			{
				m.setIndexOf(mat[i][j],k,j);
			}
			k++;
		}
		return m;
	}
	Matrix removeColumn(int c)
	{
		if (c<0||c>column-1)
		{
			Matrix m(0,0);
			return m;
		}
		int i,j,k=0;
		Matrix m(row,column-1);
		for (i=0;i<row;i++)
		{
			k=0;
			for (j=0;j<column;j++)
			{
				if(j!=c)
				{
					m.setIndexOf(mat[i][j],i,k);
					k++;
				}
			}
		}
		return m;
	}
	Matrix mergeRight(Matrix m2)
	{
		int i,j;
		if (row!=m2.row)
		{
			Matrix m(0,0);
			return m;
		}
		double** a=new double*[row];
		for (i=0;i<row;i++)
		{
			a[i]=new double[column+m2.column];
		}
		copyMatArray(a,row,column);
		for (i=0;i<row;i++)
		{
			for (j=column;j<column+m2.column;j++)
			{
				a[i][j]=m2.getIndexOf(i,j-column);
			}
		}
		Matrix m(a,row,column+m2.column);
		delete[]* a;
		return m;
	}
	Matrix mergeDown(Matrix m2)
	{
		int i,j;
		if (column!=m2.column)
		{
			Matrix m(0,0);
			return m;
		}
		
		double** a=new double*[row+m2.row];
		for (i=0;i<row+m2.row;i++)
		{
			a[i]=new double[column];
		}
		copyMatArray(a,row,column);
		for (i=row;i<row+m2.row;i++)
		{
			for (j=0;j<column;j++)
			{
				a[i][j]=m2.getIndexOf(i-row,j);
			}
		}
		Matrix m(a,row+m2.row,column);
		delete[]* a;
		return m;
	}
	bool swapConvert(int rc1,int rc2,bool isRow)
	{
		if (!isRow)
		{
			translation();
		}
		if (rc1<0||rc2<0||rc1>=row||rc2>=row)
		{
			if (!isRow)
			{
				translation();
			}
			return false;
		}
		double* tmp=new double[column];
		int i;
		for (i=0;i<column;i++)
		{
			tmp[i]=mat[rc1][i];
		}
		for (i=0;i<column;i++)
		{
			mat[rc1][i]=mat[rc2][i];
		}
		for (i=0;i<column;i++)
		{
			mat[rc2][i]=tmp[i];
		}
		delete[] tmp;
		if (!isRow)
		{
			translation();
		}
		
		return true;
	}
	bool multiConvert(int rc,double multi,bool isRow)
	{
		int i;
		if (!isRow)
		{
			translation();
		}
		if (rc<0||rc>=row)
		{
			if (!isRow)
			{
				translation();
			}
			return false;
		}
		for (i=0;i<column;i++)
		{
			mat[rc][i]*=multi;
		}
		if (!isRow)
		{
			translation();
		}
		return true;
	}
	bool multiSumConvert(int rc1,int rc2,double multi2,bool isRow)
	{
		int i;
		if (!isRow)
		{
			translation();
		}
		if (rc1<0||rc2<0||rc1>=row||rc2>=row)
		{
			if (!isRow)
			{
				translation();
			}
			return false;
		}
		for (i=0;i<column;i++)
		{
			mat[rc1][i]+=multi2*mat[rc2][i];
		}
		if (!isRow)
		{
			translation();
		}
		return true;
	}
	static Matrix getInstanceOfE(int m)
	{
		int i;
		Matrix tmp(m,m);
		for (i=0;i<m;i++)
		{
			tmp.setIndexOf(1,i,i);
		}
		return tmp;
	}
	~Matrix()
	{
		delete[]* mat;
	}
protected:
private:
	double** mat;
	int row,column;
	double det;
	int rank;
	double setDet()
	{
		if (row!=column)
		{
			return det;
		}
		if (row==1)
		{
			return (det=mat[0][0]);
		}
		if (row==2)
		{
			return (det=mat[0][0]*mat[1][1]-mat[0][1]*mat[1][0]);
		}
		det=0;
		int i,one;
		double detTmp;
		for (i=0;i<row;i++)
		{
			if (i%2==0)
			{
				one=1;
			}
			else
			{
				one=-1;
			}
			detTmp=removeRow(i).removeColumn(0).setDet();
			det+=mat[i][0]*one*detTmp;
		}
		return det;
	}
	int setRank()
	{
		bool flag;
		int i,j;
		rank=(row>column?column:row);
		while (rank!=0)
		{
			flag=true;
			for (i=0;i+rank<=column;i++)
			{
				for (j=0;j+rank<=row;j++)
				{
					if (getSubMatrix(j,i,rank,rank).getDet()==0)
					{
						flag=false;
						i=column;
						break;
					}
				}
			}
			if (flag==true)
			{
				return rank;
			}
			rank--;
		}
		return rank;
	}
};
#endif