C++数组应用之特殊矩阵的压缩存储

  矩阵:           

      矩阵是数值程序设计中经常用到的数学模型，它是由 m 行和 n 列的数值构成（m=n 时称为方阵）。在用高级语言编制的程序中，通常用二维数组表示矩阵，它使矩阵中的每个元素都可在二维数组中找到相对应的存储位置。然而在数值分析的计算中经常出现一些有下列特性的高阶矩阵，即矩阵中有很多值相同的元或零值元，为了节省存储空间，需要对它们进行"压缩存储"，即不存或少存这些值相同的元或零值元。 

操作：       

       可以对矩阵作加、减、乘等运算。

存储压缩目标：

       节约存储空间

压缩的方法：

       零元不存储

       多个值相同的只存一个

压缩存储的对象：

       稀疏矩阵

       特殊矩阵

特殊矩阵：

 值相同元素或者零元素分布有一定规律的矩阵称为特殊矩阵 例:对称矩阵、 上（下）三角矩阵都是特殊矩阵

特殊矩阵压缩存储(以对称矩阵为例)

对称矩阵是满足下面条件的n 阶矩阵: aij= aji  1<= i,j<= n

k= 0   1    2     3   4     5    6                      n(n+1)/2-1     

对称矩阵元素可以只存储下三角部分，共需 n(n+1)/2 个单元的空间( 三角矩阵的存储方式类似） 

以一维数组sa[0..n(n+1)/2-1]作为n 阶对称矩阵A的存储结构A中任意一元素 aij与它的存储位置 sa[k] 之间关系：

 

k= 0   1    2     3   4     5    6                      n(n+1)/2-1  

例如：a42 在 sa[ ]中的存储位置是：

           k=4*(4+1)/2+2=12

           sa[12]= a42

 

带状矩阵所有非0元素都集中在以主对角线为中心的带状区域，半带宽为d时, 非0元素有

(2d+1)*n-(1+d)*d个（左上角与右下角补上0后，最后必须减掉），如下图怕示：

为计算方便，认为每一行都有2d+1个非0元素，若少则0补足存放矩阵的数组sa[ ]有:n(2d+1)个元素数组，元素sa[k]与矩阵元素aij 之间有关系:

  k=i*(2d+1)+d+(j-i)（第一项i*(2d+1)表示前i行一共有几个元素，d+(j-i)这一项是用来确定第i行中，第j列前有几个元素，以i=j时，这时j-i=0，这个作为“分水岭“，左右两边的元素分别加上偏移量d。）

本例：d=1

K= 0    1         2        3      4    5     6           7    8      9      10   11    12    13      14 

（a0前以及a14处放一个0是用来表示在矩阵的左上角及右下角补上的0）

稀疏矩阵：

行数m = 6, 列数n = 7, 非零元素个数t = 6

稀疏矩阵(SparseMatrix)的抽象数据类型

 

template  < class  Type >
  class  SparseMatrix  ... {
      int Rows, Cols, Terms;    //行/列/非零元素数
      Trituple<Type> smArray[MaxTerms]; 
 public:                                 //三元组表
      SparseMatrix ( int MaxRow, int Maxcol ); 
      SparseMatrix<Type> Transpose ( );   //转置
      SparseMatrix<Type>      //相加
               Add ( SparseMatrix<Type> b );
      SparseMatrix<Type>      //相乘
            Multiply ( SparseMatrix<Type> b );
 }  

  A的三元组顺序表图示

           

三元组 (Trituple) 类的定义

template < class  Type >   class  SparseMatrix < Type > ;
template < class  Type >  
  class  Trituple  ... {   
 friend class SparseMatrix <Type>
 private:
      int row, col;       //非零元素所在行号/列号
      Type value;       //非零元素的值
 }      

                      

稀疏矩阵

转置矩阵

用三元组表表示的稀疏矩阵及其转置：

           a.smArray                                    b.smArray

（a.Rows=6,a.Cols=7,a.Terms=8）             （b.Rows=7,b.Cols=6,b.Terms=8）

 

 

稀疏矩阵转置算法思想

对应上图的一个最简单的方法是把三元组表中的row与col的内容互换，然后再按照新的row中的行号对各三元组从小到大重新排序，最后得到上图右半部分的三元组表，但是用这样的方法其时间复杂度为平方级的，下面再用一种方法来处理：

假设稀疏矩阵A有n列，相应地，需要针对它的三元组表中的col列进行n次扫描，第k次扫描是在数组的col列中查找列号为k的三元组，若找到，则意味着这个三元组所表示的矩阵元素在稀疏矩阵的第k列，需要把它存放到转置矩阵的第k行。具体办法是：取出这个三元组，并交换其row（行号）与col（列号）的内容，连同value中存储的值，作为新三元组存放到矩阵的三元组表中。当n次扫描完成时，算法结束。程序清单如下：

稀疏矩阵的转置

template  < class  Type >  SparseMatrix  < Type >  SparseMatrix  < Type > :: Transpose ( )  ... {
//将稀疏矩阵a(*this指示)转置，结果在稀疏矩阵b中。
   SparseMatrix<Type> b ( Cols, Rows );//创建一个稀疏矩阵类的对象b
     b.Rows = Cols; b.Cols = Rows; //交换其row（行号）与col（列号）的内容，连同value
b.Terms = Terms;//中存储的值作为新三元组放到矩阵的三元组表中。
     if ( Terms > 0 ) ...{ //非零元个数不为零                   
         int CurrentB = 0; //转置三元组表存放指针
for ( int k = 0; k < Cols; k++ )   //按列号做扫描，做cols次
         for ( int i = 0; i < Terms; i++ )        //在数组中找列号为k的三元组     
                 if ( smArray[i].col == k) ...{ //第i个三元组中元素的列号为k           
                  b.smArray[CurrentB].row = k; //新三元组的行号
                  b.smArray[CurrentB].col=smArray[i].row;//新三元组的列号
                  b.smArray[CurrentB].value=smArray[i].value;//新三元组的值 
                 CurrentB++;                                              //存放指针加1                    
               }
     }
     return 0;
 }

  若设稀疏矩阵的行数为Rows，列数为Cols，非零元素个数为Terms，则最坏情况下的时间复杂度主要取决于二重潜套for循环内的if语句，if语句在二重循环的作用下总的执行次数为O（Cols*Terms）。而在if控制内的赋值语句则执行了Terms次，它取决于三元组表本身的长度。若非零元素个数Terms与矩阵行，列数的乘积Rows*Cols等数量级，则上述程序清单的时间复杂度为O(Cols*Terms)＝O（Rows*Cols*Cols）。设Rows=500,Cols=100,Terms=10000,则O(500*100*100)=O(5000 000)，处理效率极低。

为了提高转置效率，采用一种快速转置的方法。在此方法中，引入两个辅助数组：

1． rowSize[]。用它存放事先统计出来的稀疏矩阵各列的非零元素个数，转置以后是转置矩阵各行的非零元素个数。具体做法是：先把这个数组清零，然后扫描矩阵A的三元组表，逐个取出三元组的列号col，把以此列号为下标的辅助数组元素的值累加1。

for(int i=0;i

 for(j=0;jrowSize[smArray[j].col]++;//统计，注意这里用到的简洁的算法

2． rowstart[]。用它存放事先计算出来的稀疏矩阵各行非零元素在转置矩阵的三元组表中应存放的位置。

rowSize[0]=0;//计算矩阵b第i行非零元素的开始存放位置

for(i=1;i

快速转置算法的思想

Ø         建立辅助数组 rowSize 和 rowStart，记录矩阵转置后各行非零元素个数和各行元素在转置三元组表中开始存放位置。

Ø         扫描矩阵三元组表，根据某项的列号，确定它转置后的行号，查 rowStart 表，按查到的位置直接将该项存入转置三元组表中。

Ø         转置时间代价为O(max(Terms, Cols))。若矩阵有200 列，10000个非零元素，总共需要10000次处理。

对应上图的代码在就像前面所列的：

 for ( int i = 0; i < Cols; i++ ) rowSize[i] = 0;  

 for ( i = 0; i < Terms; i++ )

       rowSize[smArray[i].col]++; 

 rowStart[0] = 0;                              

 for ( i = 1; i < Cols; i++ )                

       rowStart[i] = rowStart[i-1]+rowSize[i-1];

 

稀疏矩阵的快速转置

template  < class  Type >  SparseMatrix < Type >
SparseMatrix < Type > ::FastTranspos ( )  ... {
//对稀疏矩阵a(*this指示)做快速转置，结果放在b中，时间代价为O(Terms+Columns)。
    int *rowSize = new int[Cols];//辅助数组，统计各列非零元素个数           
    int *rowStart = new int[Cols];//辅助数组，预计转置后各行存放位置                    
    SparseMatrix<Type> b ( Cols, Rows );//存放转置结果            
    b.Rows = Cols;   b.Cols = Rows;
   b.Terms = Terms;
    if ( Terms > 0 ) ...{
        for (int i = 0; i < Cols; i++) rowSize[i] = 0;//统计矩阵b中第i行非零元素个数
for ( i = 0; i < Terms; i++ )
//根据矩阵a中第i个非零元素的列号，将rowSize相当该列的计数加1
        rowSize[smArray[i].col]++; 
rowStart[0] = 0;     //计算矩阵b第i行非零元素的开始存放位置
         for ( i = 1; i < Cols; i++ ) //rowStart[i]=矩阵b的第i行的开始存放位置          
           rowStart[i] = rowStart[i-1]+rowSize[i-1];
       for ( i = 0; i < Terms; i++ ) ...{      //从a向b传送            
           int j = rowStart[smArray[i].col];//j为第i个非零元素在b中应存放的位置              
           b.smArray[j].row = smArray[i].col;
           b.smArray[j].col = smArray[i].row;
           b.smArray[j].value = smArray[i].value;
           rowStart[smArray[i].col]++;         
       }
    }
    delete[ ] rowSize;   delete [ ] rowStart;
    return b;
}

在此程序中有4个并列循环，其时间复杂度分别为O(Cols),O(Terms),O(Cols),和O（Terms），则程序总的时间复杂度为O(Cols+Terms)。当Terms与Rows*Cols等数量级时，程序的时间复杂度为O(Cols＋Terms)＝O(Rows*Cols)。设Rows=500，Cols＝100,Terms=10000,则O（500*100）=O（50000）。当Terms远远小于Rows*Cols时，此程序会更省时间，但程序中需要增加两个体积为Cols的辅助数组。一般Terms总是大于Cols的，如果能够大幅度提高速度，这点空间存储上的开销是值得的。