什么是稀疏矩阵呢,就是在M * N的矩阵中,有效值的个数远小于无效值的个数,并且这些数据的分布没有规律。在压缩存储稀疏矩阵的时候我们只存储极少数的有效数据。我们在这里使用三元组存储每一个有效数据,三元组按原矩阵中的位置,以行优先级先后次序依次存放。下面我们来看一下代码实现。
# include
# include
# include
使用名称空间性病;
template<类T>
类SparseMatrix
{//三元组
template<类T>
struct Trituple
{
Trituple()//给一个默认构造函数
{}
Trituple (size_t行,size_t坳,const T&数据)
:_row(行)
_col (col)
_data(数据)
{}
size_t _row;
size_t _col;
T _data;
};
公众://稀疏矩阵的压缩存储
SparseMatrix ()
{}
SparseMatrix (int *加勒比海盗,size_t行,size_t坳,const T&无效的)
:_row(行)
_col (col)
_invalid(无效)
{
for (int i=0;我& lt;行;我+ +)
{
for (int j=0;j & lt;上校;+ + j)
{
如果(arr[我*坳+ j] !=无效)//将有效值存储在一个一维数组中
_sm.push_back (Trituple (i, j, arr [i *坳+ j]));//将三元组的无名对象进推去
}
}
}//访问稀疏矩阵中连续行中上校的元素
T&访问(int, int)上校
{//1,/* (int idx=0;idx & lt;_sm.size ();idx + +)//遍历一遍
{
如果(_sm [idx]。_row==行,,_sm [idx]。_col==坳)//当前行列与我们要访问那个元素行列相同时返回这个有效值
返回_sm [idx] ._data;
}
返回_invalid; *///否则返回无效值//2,
vector祝辞::iterator它=_sm.begin();//定义一个迭代器,指向起始位置
而(它!=_sm.end())//未到最后一个元素时
{
如果→_row==行,,它→_col==坳)//行列相等输出值
返回它→_data;
+ +,//迭代器向后移动
}
返回_invalid;
}//还原稀疏矩阵
template
朋友ostream&operator<& lt; (ostream&_cout SparseMatrix和;)//重载& lt; & lt;
{
size_t国际防务展=0;
(size_t我=0;我& lt;s._row;我+ +)
{
(size_t j=0;j & lt;s._col;j + +)
{
如果(国际防务展& lt;s._sm.size()/*防止数组越界*/,,s._sm[国际防务展]。_row==我,,s._sm[国际防务展]。_col==j)
{
_cout<& lt; s._sm[国际防务展]._data<& lt;“”;
+ +国际防务展;
}
其他的
_cout<& lt; s._invalid<& lt;“”;
}
_cout<& lt; endl;
}
返回_cout;
}//实现稀疏矩阵的逆置时间复杂度O (M * N) (M为元素个数N为矩阵列数)
SparseMatrix运输()
{
SparseMatrixsm;
sm。_row=_col;
sm。_col=_row;
sm。_invalid=_invalid;
(size_t我=0;我& lt;_col;我+ +)
{
vector祝辞::iterator它=_sm.begin ();
而(它!=_sm.end ())
{
如果→_col==我)//从原矩阵第0列开始,将每列中的有效值依次放入新的稀疏矩阵
sm._sm.push_back (Trituple(我→_row,→_data));
+ +;
}
}
返回sm;
}//实现稀疏矩阵的快速转置时间复杂度O (N) + O (M)
SparseMatrixFastTransport ()
{
SparseMatrixsm;
sm。_col=_row;
sm。_row=_col;
sm。_invalid=_invalid;
sm._sm.resize (_sm.size());//开辟空间//1、统计原矩阵中每一列有多少个有效元素
int * pCount=new int [_col];//开辟原矩阵中列个数的空间
memset (pCount 0 _col * sizeof (pCount [0]));
for (int i=0;我& lt;_sm.size ();我+ +)
pCount [_sm[我]._col] + +;//2、原矩阵每一列在新矩阵中的起始位值
int * pAddr=new int [_col];
memset (pAddr 0 _col * sizeof (pAddr [0]));
for (int i=1/*从1开始,第一个位置起始为0已经放入*/;我& lt;_sm.size ();我+ +)
{
pAddr[我]=pAddr (i - 1) + pCount [i - 1];//前一个起始位值+前一列有效元素个数
}//3、放置元素到新空间
for (int i=0;我& lt;_sm.size ();我+ +)
{
int&addr=pAddr [_sm[我]._col];
sm。_sm (addr)=Trituple (_sm[我]._col _sm[我]._row _sm[我]._data);
addr + +;
}
返回sm;
}//实现稀疏矩阵的加法操作1/* SparseMatrix操作符+ (const SparseMatrix和sp)
{
int i=0 j=0 k=0;
T v;
SparseMatrix年代;
如果(这→_col !=sp._col | |这→_row !=sp._row)
退出(1);
年代。_row=sp._row;
年代。_col=sp._col;
年代。_invalid=sp._invalid;
虽然(我& lt;这→_sm.size (),,j & lt;sp._sm.size ())
{
如果(这→_sm[我]。_row==sp._sm [j] ._row)
{
如果(这→_sm[我]。_col & lt;sp._sm [j] ._col)
{
s._sm.push_back (Trituple
