稀疏矩阵（实现快速转置和普通转置）

1.M*N的矩阵，矩阵中有效值的个数远小于无效值的个数，且这些数据的分布没有规律。

2.稀疏矩阵的压缩存储：

压缩存储值存储极少数的有效数据。使用{row,col,value}三元组存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后顺序依次存放。

 3.矩阵的转置：

将原矩阵的行、列对换，也就是将[i][j]和[j][i]位置上的数据对换。（转置有快速转置和普通转置）

template<class T>
struct Triple     //三元组
{
	Triple(size_t row,size_t col,const T& data)
		:_row(row)
		,_col(col)
		,_data(data)
	{}
	Triple(){}
	size_t _row;
	size_t _col;
	T _data;
};
template<class T>
class SparseMatrix
{
public:
	SparseMatrix(){}
	SparseMatrix(T* a,size_t m,size_t n,const T& invalid)   //数组 行 列 非法值
		:_m(m)
		,_n(n)
		,_invalid(invalid)
	{
		for(size_t i=0;i<_m;i++)
		{
			for(size_t j=0;j<_n;j++)
			{
				if(a[i*_n+j]!=_invalid)
				{
					v.push_back (Triple<T>(i,j,a[i*_n+j]));
				}
			}
		}
	}
	//普通转置
	SparseMatrix<T> TransposedMatrix()
	{
		SparseMatrix<T> sm;
		sm._m =_n;//_m=5行
		sm._n =_m;//_n=6列
		sm._invalid =_invalid;
		sm.v.reserve (v.size());

		for(size_t i=0;i<_n;++i)
		{
			size_t index=0;
			while(index<v.size())
			{
				if(v[index]._col==i)
				{
					Triple<T> t(v[index]._col,v[index]._row,v[index]._data);
					sm.v .push_back (t);
				}
				++index;
			}

		}
		return sm;
	}
	//快速转置
	SparseMatrix<T> FastTransposedMatrix()
	{
		SparseMatrix<T> sm;
		sm._m =_n;//_m=5行
		sm._n =_m;//_n=6列
		sm._invalid =_invalid;
		sm.v.resize (v.size());

		int* count=new int[_n]; //统计转置后每一行数据的个数
		memset(count,0,_n*sizeof(int));
		int* start=new int[_n];  //统计转置后每一行在压缩矩阵存储的开始位置

		//统计个数转置后的
		size_t index=0;
		while(index<v.size ())
		{
			int row=v[index]._col;
			count[row]++;
			++index;
		}
		//开始位置
		start[0]=0;
		for(size_t i=1;i<_n;++i)
		{
			start[i]=start[i-1]+count[i-1];
		}
		index=0;
		while(index<v.size())
		{
			Triple<T> t(v[index]._col,v[index]._row,v[index]._data);//三元组
			int row=v[index]._col;   //得到行
			int begin=start[row];   //得到这一行转置后在v的初始位置
			sm.v[begin]=t;          //在把这个数的信息插入进去
			start[row]++;
			++index;
		}
		delete[] count;
		delete[] start;
		return sm;
	}
	~SparseMatrix()
	{}
	void Display()
	{
		size_t k=0;
		for(size_t i=0;i<_m;i++)
		{
			for(size_t j=0;j<_n;j++)
			{
				if((i==v[k]._row)&&(j==v[k] ._col))
				{
					cout<<v[k] ._data<<" ";
					if(k<v.size ()-1)
						k++;
				}
				else
					cout<<_invalid<<" ";
			}
			cout<<endl;
		}
	}
protected:
	vector<Triple<T>> v;
	size_t _m;
	size_t _n;
	T _invalid;
};
void TestSparseMatrix()
{
	int a[6][5]=
	{
		{1,0,3,0,5},
		{0,0,0,0,0},
		{0,0,0,0,0},
		{2,0,4,0,6},
		{0,0,0,0,0},	
		{0,0,0,0,0},		
	};
	SparseMatrix<int> sm((int*)a,6,5,0);
	sm.Display ();
	/*SparseMatrix<int> tsm=sm.TransposedMatrix();
	tsm.Display ();*/
	SparseMatrix<int> ftsm=sm.FastTransposedMatrix ();
	ftsm.Display ();
}