稀疏矩阵

稀疏矩阵就是矩阵中分布着很多零元素（零元素个数远远大于非零元素个数），如果将这个矩阵的每个元素都一一存储，那是很浪费空间的。因此，可以采用一些特殊的存储结构来存储它。有以下几种方法：

1.顺序存储：三元组表示法、伪地址表示法

2.链式存储：邻接表表示法、十字链表表示法

这里介绍三元组表示法。

稀疏矩阵

三元组数据结构为一个长度为n，表内每个元素都有3个分量的线性表，其3个分量分别为值、行下标和列下标。

元素结构体定义如下：

 typedef struct
 {
     int val;
     int i,j;
 }Trimat;
 ​
 //定义一个含有maxterms个非零元素的稀疏矩阵的三元组
 Trimat trimat[maxterms+1];//maxterms是已经定义好的常量

 

为了简便起见，可以不使用上述结构体定义，直接申请一个如下的数组即可：

 int trimat[maxterms+1][3];

 trimat[k] [0]表示原矩阵中的元素按行优先顺序的第k个非零元素的值；trimat[k] [1]和trimat[k] [2]表示第k个元素在矩阵中的位置。规定第0行的3个元素分别用来存储非零元素个数、行数和列数。

 

建立三元组

 //A是m*n的稀疏矩阵，B是三元组，maxSize是预先定义好的最大矩阵维数  
 void createTrimat(int A[][maxSize],int m,int n,int B[][3])
 {
     int k=1;//B的行
     for(int i=0;i<m;i++)
     {
         for(int j=0;j<n;j++)
         {
             if(A[i][j]!=0)//找到非零元素，放入三元组 
             {
                 B[k][0]=A[i][j];
                 B[k][1]=i;
                 B[k][2]=j;
                 k++; 
             }
         }
     } 
     //三元组第一行信息 
     B[0][0]=k-1;
     B[0][1]=m;
     B[0][2]=n;
 }

 

通过三元组打印矩阵

 void print(int B[][3])
 {
     int k=1;
     for(int i=0;i<B[0][1];i++)
     {
         for(int j=0;j<B[0][2];j++)
         {
             if(i==B[k][1]&&j==B[k][2])//(i,j)在三元组中 
             {
                 cout<<B[k][0]<<" ";
                 k++;
             }
             else
                 cout<<"0 ";
         }
         cout<<endl;
     }
 }

 测试

 int main()
 {
     int A[maxSize][maxSize]={{0,0,0,1},
                              {0,0,3,2},
                              {1,0,0,0},
                              {0,2,0,0}};
     int B[maxterms+1][3];
     //稀疏矩阵A 转 三元组B 
     createTrimat(A,4,4,B);
     //打印B 
     for(int i=0;i<6;i++)
     {
         for(int j=0;j<3;j++)
             cout<<B[i][j]<<" ";
         cout<<endl;
     }
     cout<<endl;
     //由B打印A 
     print(B);
      
     return 0;
 }

运行

 

练习

 

1.假设稀疏矩阵A采用三元组表示，编写一个函数，计算其转置矩阵B，要求B也采用三元组表示。

分析：因为三元组内元素是原矩阵按行优先存储的结果，所以不能仅仅将行下标和列下标互换。B中的元素从上往下的顺序是B原矩阵按行从左到右从上到下的顺序，因为转置，B矩阵的第一行是A的第一列，因此正确的做法是找出A的第一列元素，把他们依次放入B的三元组中，然后找A的第二列元素、第三列元素......

 void transpose(int A[][3],int B[][3])
 {
     //更新B的第一行信息 
     B[0][0]=A[0][0];
     B[0][1]=A[0][2];
     B[0][2]=A[0][1];
     if(B[0][0]>0)
     {
         int q=1;//B的行
         for(int i=0;i<B[0][1];i++) //B的行数 
         {
             for(int k=1;k<=B[0][0];k++)
             {
                 if(A[k][2]==i)//A的列等于B的行
                 {
                     B[q][0]=A[k][0];
                     B[q][1]=A[k][2];
                     B[q][2]=A[k][1];
                     q++;
                 } 
             }
         }
     }
 } 

 

2.假设稀疏矩阵A和B（两矩阵行列数对应相等）都采用三元组表示，编写一个函数，计算C=A+B，要求C也采用三元组表示，所有矩阵均为int型。

 void add(int A[][3],int B[][3],int C[][3])
 {
     
     int i=1,j=1;//i遍历A，j遍历B
     int k=1;//C的行 
     while(i<=A[0][0]&&j<=B[0][0])
     {
         if(A[i][1]==B[j][1])//如果A当前元素的行号等于B当前元素的行号，则比较列号 
         {
             if(A[i][2]<B[j][2])//A的列号小于B的列号，则将A这个元素写入C 
             {
                 C[k][0]=A[i][0];
                 C[k][1]=A[i][1];
                 C[k][2]=A[i][2];
                 k++;
                 i++;
                 
             }
             else if(A[i][2]>B[j][2])//A的列号大于B的列号，则将B这个元素写入C 
             {
                 C[k][0]=B[j][0];
                 C[k][1]=B[j][1];
                 C[k][2]=B[j][2];
                 k++;
                 j++;
             }
             else //A的列号等于B的列号，则将这两个元素相加，写入C 
             {
                 int m=A[i][0]+B[j][0];
                 if(m!=0)//m有可能为0，不为0才写入C 
                 {
                     C[k][0]=m;
                     C[k][1]=A[i][1];
                     C[k][2]=A[i][2];
                     k++;
                      
                 } 
                 i++;
                 j++;
             }
         }
         else if(A[i][1]<B[j][1])//A当前元素的行号小于B当前元素的行号，则将A的这个元素写入C 
         {
             C[k][0]=A[i][0];
             C[k][1]=A[i][1];
             C[k][2]=A[i][2];
             k++;
             i++;
         }
         else //A当前元素的行号大于B当前元素的行号，则将B的这个元素写入C
         {
             C[k][0]=B[j][0];
             C[k][1]=B[j][1];
             C[k][2]=B[j][2];
             k++;
             j++;
         }
     }
         
         while(i<=A[0][0])//A有剩余元素，B已经处理完毕，将A中元素直接放入C 
         {
             C[k][0]=A[i][0];
             C[k][1]=A[i][1];
             C[k][2]=A[i][2];
             k++;
             i++;     
    } 
     
while(j<=B[0][0])//B有剩余元素，A已经处理完毕，将B中元素直接放入C  
    { 
C[k][0]=B[j][0]; 
C[k][1]=B[j][1]; 
C[k][2]=B[j][2]; 
k++; 
j++; 
    } 
     
//产生第0行信息  
C[0][0]=k-1;  
C[0][1]=A[0][1]; 
C[0][2]=A[0][2]; 
}

 

3.假设稀疏矩阵A和B（分别为m*n和n*k矩阵）采用三元组表示，编写一个函数，计算C=A*B，要求C也是采用三元组表示的稀疏矩阵。

 //返回D对应的稀疏矩阵中（i,j）位置上的值 
 int getValue(int D[][maxSize],int i,int j)
 {
     int k=1;
     whilt(k<=D[0][0]&&(D[k][1]!=i||D[k][2]!=j))
         k++;
     if(k<=D[0][0])
         return D[k][0];
     else 
         return 0;
 }
 //矩阵相乘 
 void mul(int A[][3],int B[][3],int C[][3],int m,int n,int k)
 {
     int p=1;//C的行 
     for(int i=0;i<m;i++)
     {
         for(int j=0;j<k;j++)
         {
             for(int l=0;l<n;l++)//A的第m行乘B的第k列 为 C的(m,k)
                 s+=getValue(A,i,l)+getValue(B,l,j);
             if(s!=0)
             {
                 C[p][0]=s;
                 C[p][1]=i;
                 C[p][2]=j;
                 p++;
             }
         }
     }
     C[0][0]=p-1;
     C[0][1]=m;
     C[0][2]=k; 
 }