稀疏矩阵的转置

稀疏矩阵：M*N的矩阵，矩阵中的有效值的个数远小于无效值的个数，而且这些数分布没有规律。

压缩存储的值极少，采用三元组（value,row,col）存储每一个有效值。三元组按照在原矩阵的位置，按照行优先存储。

构造函数：

SparseMatrix(T* a,size_t m,size_t n,const T& invalid)
		:_rowsize(m)
		,_colsize(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)
				{
					_a.push_back(Triple<T>(a[i*n+j],i,j));
				}
			}
		}
	}

打印函数：

void Display()
	{
		size_t index=0;
		for(size_t i=0;i<_rowsize;i++)
		{
			for(size_t j=0;j<_colsize;j++)
			{
				if((index<_a.size())&&(_a[index]._row==i)&&(_a[index]._col==j))
					{
						cout<<_a[index]._value<<" ";
						index++;
				    }
				else
					cout<<_invalid<<" ";

			}
			cout<<endl;
		}
		cout<<endl;
	}

普通转置：

SparseMatrix<T> Transport()//O(colsize*有效数值的个数)
	{
		SparseMatrix<T> tmp;
		tmp._rowsize=_colsize;
		tmp._colsize=_rowsize;
		tmp._invalid=_invalid;
		for(size_t i=0;i<_colsize;i++)
			{
				size_t index=0;
				while(index<_a.size())
				{
					for(size_t j=0;j<_a.size();j++)
				  {
					if(_a[j]._col==i)
					{
						tmp._a.push_back(Triple<T>(_a[index]._value,_a[index]._row,_a[index]._col));
					}
					++index;
				  }
				}
			}
		return tmp;
	}

快速转置：

快速转置借用两个数组来实现，rowCount用来存储统计转置后的矩阵每一行的数据个数，rowStart用来存储统计转置后的矩阵每行有效数值在压缩矩阵存储的位置，例如转置后第二行的第一个数在压缩存储的位置等于第一行的第一个有效值的位置+第一行有效值的个数（rowStart[2]=rowStart[1]+rowCount[1]）

SparseMatrix<T> FastTransport()
	{
		SparseMatrix<T> tmp;
		tmp._rowsize=_colsize;
		tmp._colsize=_rowsize;
		tmp._invalid=_invalid;

		int* rowCount=new int[_colsize];
		int* rowStart=new int[_colsize];
		memset(rowCount,0,sizeof(int)*_colsize);
		memset(rowStart,0,sizeof(int)*_colsize);

		size_t index=0;
		while(index<_a.size())//统计转置后的矩阵每一行的数据个数
		{
			rowCount[_a[index]._col]++;
			++index;
		}

		rowStart[0]=0;//统计转置后的矩阵每行有效数值在压缩矩阵存储的位置
		for(size_t i=1;i<_colsize;i++)
		{
			rowStart[i]=rowStart[i-1]+rowCount[i-1];
		}

		index=0;
		tmp._a.resize(_a.size());//增加容量，改变size，并初始化
		while(index<_a.size())
		{
			Triple<int> t;
			t._col=_a[index]._row;
			t._row=_a[index]._col;
			t._value=_a[index]._value;
			tmp._a[rowStart[_a[index]._col]++]=t;
			++index;
		}
		return tmp;
	}

三元组：

template<class T>
struct Triple//三元组
{
	Triple(const T& value=T(),size_t row=0,size_t col=0)
		:_value(value)
		,_row(row)
		,_col(col)
	{}
	T _value;
	size_t _row;
	size_t _col;
};

稀疏矩阵压缩存储的成员变量：

vector<Triple<T> > _a;
	size_t _rowsize;
	size_t _colsize;
	T _invalid;