稀疏矩阵的对称矩阵的转置

SymmentryMatrix(对称矩阵)

    对称矩阵和对称矩阵的压缩存储>

        设一个N*N的方阵Array,Array中任意元素Arrayij,当且仅当Arrayij == Arrayji(0 <= i <= N-1 && 0 <= j <= N-1),Array是对称矩阵。以矩阵的对角线为分隔，分为上三角和下三角.

      我们发现如果将该对称矩阵的每个元素都存入则会存在内存浪费问题，那仫如何解决？ 这就提到了对称矩阵的压缩存储了--则只需要存储上三角或者下三角的元素即可节省一半空间。

     注意：

     (1).在对称矩阵的压缩存储中因为只存储上三角或者下三角则每一行的有效数据为：0,1,2,3,4(以5*5的方阵为例),那么根据等差数列的特性最多存储n*(n+1)/2个元素

     (2).在输出压缩存储的对称方阵的时候，假设存储的是下三角，如果该下标属于下三角(i >= j)则直接输出,如果要输出的下标属于上三角(i < j)则需要将该上三角的行列交换.

     

//对称矩阵的存储  
02.template<typename T>  
03.class SymMatrix  
04.{  
05.public:  
06.    SymMatrix(T *matrix,size_t n)  
07.        :_matrix(new T[n*(n+1)/2])  
08.        ,_size(n*(n+1)/2)  
09.        ,_n(n)  
10.    {  
11.        for(size_t i=0;i<n;++i)   //存储下三角  
12.        {  
13.            for(size_t j=0;j<n;++j)  
14.            {  
15.                if (i >= j)  
16.                {  
17.                    _matrix[i*(i+1)/2+j]=matrix[i*n+j];  
18.                }  
19.            }  
20.        }  
21.    }  
22.    T& Access(size_t i,size_t j)  
23.    {  
24.        if(i < j)    //如果是上三角元素  
25.        {  
26.            swap(i,j);  
27.        }  
28.        return _matrix[i*(i+1)/2+j];  
29.    }  
30.    void PrintSymMatrix()  
31.    {  
32.        for (size_t i=0;i<_n;++i)  
33.        {  
34.            for(size_t j=0;j<_n;++j)  
35.            {  
36.                cout<<Access(i,j)<<" ";  
37.            }  
38.            cout<<endl;  
39.        }  
40.        cout<<endl;  
41.    }  
42.protected:  
43.    T* _matrix;  
44.    size_t _size;  
45.    size_t _n;  
46.}; 

 

     稀疏矩阵的三元组存储和稀疏矩阵的两种转置算法>

     M*N的矩阵，矩阵中有效值的个数远远小于无效值的个数，且有效值的分布没有规律，这就是稀疏矩阵.如何高效的去存储一个稀疏矩阵呢？要想高效的存储一个稀疏矩阵则只需要存储该矩阵的有效值即可,但是存在一个问题就是如何找到该有效值的位置呢？直接将该有效值的行，列坐标一起存储起来不就可以了吗？这就是稀疏矩阵的三元组存储形式.且值得注意的是该矩阵是以行优先的方法存储的.

    稀疏矩阵的两种转置算法>

    一.普通的转置算法

       

普通转置算法的时间复杂度为O(原来稀疏矩阵的列*有效值的个数).

      

[cpp] 
01.SpareMatrix<T> Transport()   //矩阵的转秩--普通算法  
02.{  
03.    SpareMatrix<T> tsm;  
04.    tsm._row=_col;  
05.    tsm._col=_row;  
06.    tsm._v.reserve(_v.size());  
07.    for (size_t i=0;i<_col;++i)  
08.    {  
09.        //i控制新矩阵的行也就是旧矩阵的列  
10.        size_t index=0;  
11.        while (index < _v.size())  
12.        {  
13.            //index控制原来三元组的元素个数  
14.            if (_v[index]._cols == i)  
15.            {  
16.                //遍历原来的三元组如果存在满足对应下标的元素则进入新的三元组.  
17.                Triple<T> tmp(_v[index]._cols,_v[index]._rows,_v[index]._value);  
18.                tsm._v.push_back(tmp);  
19.            }  
20.            ++index;  
21.        }  
22.    }  
23.    return tsm;  
24.}  

二.快速转置算法>

      在之前普通的转置算法中，将原来的三元组遍历了N(原来三元组的列)遍，效率不高，这就提到了快速转置.

      (1).如果我们可以统计出转置之后的矩阵每一行有效值的个数，并找到转置之后每一行第一个元素在新三元组的存储位置，此时再遍历原来的三元组将有效数据直接放入新三元组的对应位置处，不是更加高效吗？此时的时间复杂度为O(2*有效值的个数+N)

      (2).CountNum统计新矩阵每一行的有效值的个数等价于统计原来矩阵的每一列的有效值的个数,这里就有点哈希表的思想了,通过遍历原来的三元组，将原来三元组的列下标作为CountNum的下标，只要原来三元组的列存在有效值该CountNum的对应下标就+1.

      (3).StartPos找到新矩阵的每一行的第一个元素在新三元组的存储下标

      (4).此时再次遍历原来的三元组，将该数据直接放入新三元组对应的下标处,此时将StartPos位置的存储数据+1,防止插入到相同的位置处.

SpareMatrix<T> FastTransport()     //矩阵的转秩--快速算法  
02.{  
03.    SpareMatrix<T> ftsm;  
04.    ftsm._row=_col;  
05.    ftsm._col=_row;  
06.    ftsm._v.resize(_v.size());  
07.    //新矩阵的行就是旧矩阵的列  
08.    //CountNum统计新矩阵每一行有效值的个数  
09.    int *CountNum=new int[_col];  
10.    memset(CountNum,0,sizeof(int)*_v.size());  
11.    for (size_t i=0;i<_v.size();++i)  
12.    {  
13.        CountNum[_v[i]._cols]++;  
14.    }  
15.    //StartPos记录新矩阵的每一行第一个元素在三元组的存储下标  
16.    int *StartPos=new int[_col];  
17.    memset(StartPos,0,sizeof(int)*_v.size());  
18.    size_t i=0;  
19.    StartPos[i]=0;  
20.    for (i=1;i<_col;++i)  
21.    {  
22.        StartPos[i]=StartPos[i-1]+CountNum[i-1];  
23.    }  
24.    //遍历旧的三元组，找到数据就直接放入新三元组的对应的下标处  
25.    for (size_t i=0;i<_v.size();++i)  
26.    {  
27.        size_t tmp=StartPos[_v[i]._cols];  
28.        ftsm._v[tmp]._rows=_v[i]._cols;  
29.        ftsm._v[tmp]._cols=_v[i]._rows;  
30.        ftsm._v[tmp]._value=_v[i]._value;  
31.        StartPos[tmp]++;  
32.    }  
33.    return ftsm;  
34.}