稀疏矩阵的转置和快速转置

稀疏矩阵压缩存储：

代码：

#pragma once

#include<vector>
using namespace std;

template<class T>
struct Triple
{
Triple()
{}
Triple(T & v, int r, int c)
:_value(v)
, _row(r)
, _col(c)
{}
size_t _row;
size_t _col;
T _value;
};

//稀疏矩阵的压缩存储
template<class T>
class SparseMatrix
{
public:
SparseMatrix()
:_RowSize(0)
, _ColSize(0)
{
}
SparseMatrix(T * a, size_t row, size_t col,const T & invalid)
:_RowSize(row)
, _ColSize(col)
, _invalid(invalid)
{
for (size_t i = 0; i < _RowSize; ++i)
{
for (size_t j = 0; j < _ColSize; j++)
{
if (a[i*_ColSize + j] != invalid)
{
Triple<T> t(a[i*_ColSize + j], i, j);
_array.push_back(t);
}
}
}
}

void Display()
{
size_t index = 0;
for (size_t i = 0; i < _RowSize; ++i)
{
for (size_t j = 0; j < _ColSize; j++)
{
if (index<_array.size()&&_array[index]._row==i &&_array[index]._col==j )
{
cout << _array[index++]._value << " ";
}
else
{
cout << _invalid<<" ";
}
}
cout << endl;
}
cout << endl;
}
private:
vector<Triple<T>> _array;
size_t _RowSize;
size_t _ColSize;
T _invalid;  //非法值
};

//转置算法为成员函数，在下面列出

一般转置算法：从保存矩阵的数组中抽取列为index的元素，转换行列值后，插入到新的矩阵中，经过列数col次迭代，即可完成转置。

完整代码如下：

SparseMatrix<T> Transpose()  //转置
{
SparseMatrix sm;
sm._RowSize = _ColSize;
sm._ColSize = _RowSize;
sm._invalid = _invalid;
int i=0;
for (int j = 0; j < _ColSize; ++j)
{
i = 0;
while ( i < _array.size())
{
if (j == _array[i]._col)
{
Triple<T> t(_array[i]._value, _array[i]._col, _array[i]._row);
sm._array.push_back(t);
}
++i;
}
}
return sm;
//O(有效元素数*列数)
}

<pre name="code" class="cpp">

快速转置算法：经过常数次运算，求出转置后，每行的起始位置，之后遍历一次存储矩阵的数组进行迭代插入，这样可以在O(n)的时间复杂度下完成转置。

SparseMatrix<T> Transpose()  //转置
{
SparseMatrix sm;
sm._RowSize = _ColSize;
sm._ColSize = _RowSize;
sm._invalid = _invalid;
int i=0;
for (int j = 0; j < _ColSize; ++j)
{
i = 0;
while ( i < _array.size())
{
if (j == _array[i]._col)
{
Triple<T> t(_array[i]._value, _array[i]._col, _array[i]._row);
sm._array.push_back(t);
}
++i;
}
}
return sm;
//O(有效元素数*列数)
}
SparseMatrix<T> FastTranspose()   //快速转置
{
SparseMatrix sm;
sm._ColSize = _RowSize;
sm._RowSize = _ColSize;
sm._invalid = _invalid;
sm._array.resize(_array.size());  //这块会调用默认构造函数 所以Triple必须默认构造函数
int index = 0;
int* RowCount = new int[_ColSize];
int* RowStart = new int[_ColSize];
memset(RowCount, 0, sizeof(int)*_ColSize);
memset(RowStart, 0, sizeof(int)*_ColSize);

while (index < _array.size())  //一次迭代O(n)
{
++RowCount[_array[index++]._col];
}
index = 1;
while (index < _ColSize)      //O(n)
{
RowStart[index] = RowStart[index - 1] + RowCount[index - 1];
++index;
}

//执行快速转置
int i = 0;
while (i < _array.size())  //两次迭代 O(n)
{

Triple<T>  t(_array[i]._value, _array[i]._col, _array[i]._row);
sm._array[RowStart[_array[i]._col]++] = t;
++i;
}

delete[] RowCount;
delete[] RowStart;

return sm;

//时间复杂度O(有效元素数*常数次迭代)
}