稀疏矩阵

矩阵的标准存储表示是用一个二维数组表示，用a[MAX_ROW][MAX_COL]这种存储表示 ，用a[i][j]可以确定一个元素.但是当元素中0的个数较多时将会浪费许多空间。

稀疏矩阵是用一个3元组（行列元素值）只存储非0元素。

如矩阵

15　　 0 　　0 　　22　　 0 　　-15
0　　   11　   3 　　0 　　  0　　 0
0 　　  0 　　0　　 -6 　 　0 　　0
0 　　  0 　　0 　　0　　   0 　　0
91　　 0 　　0　　 0 　　  0 　　0
0 　　  0 　　28　   0　　   0 　   0

稀疏矩阵存储为：

行  列  值
6 　　 6 　　 8
0 　　 0 　　 15
0 　　 4 　　 91
1  　　1 　　 11
2 　　 1  　　3
2 　　 5 　　 28
3 　　 0　　  22
3 　　 2　　  -6
5  　　0 　　 -15

按行转置;　　　　　　　　按列转置后;

0　　0　　15　　　　　　0　　0　　15

3　　0　　22　　　　　　0　　3　　22

5　　0　　-15　　

由上可知按行转置后会导致转置之后的矩阵无序导致插入删除不方便

而按列转置顺序依旧存在，所以按列转置较好　　　　

#include<stdio.h>
#define MAX_TERMS 101 //最大元素个数加1第一个用于存储数组 行数列数元素数 
#define MAX_COL   50  //最大列加1 
typedef struct  {
    int col;
    int row;
    int value; 
} term;
term   a[MAX_TERMS];
void transpose(term a[],term b[]);
void fast_transpose(term a[],term b[]);


void transpose(term a[],term b[])//时间是col*elements 
{
    /*
    思路:当矩阵不是非0矩阵时，求a矩阵的每一列的元素，转置为b的每一行的元素 
    具体就是扫描a表max_col次，每次找出相同的列转置为行 
    不按行转置是因为会打乱顺序，而按照列转置是有序的 
    */ 
    int n,i,j,bcurrent;
    n=a[0].value;
    b[0].row=a[0].col;
    b[0].col=a[0].row;
    b[0].value=n;
    if( n > 0 ){ 
        //非0矩阵        
        bcurrent=1;
        for(i=0;i<a[0].col;i++){
            //按a的列转置 
            for(j = 1;j <n; j++){
                //找出当前列所有元素 
                 if(a[j].col==i){
                     //是当前列加入b 
                     b[bcurrent].row=a[j].col;
                     b[bcurrent].col=a[j].row;
                     b[bcurrent].value=a[j].value;
                     bcurrent++;
                 } 
            }    
        }
    } 
} 
void fast_transpose(term a[],term b[])//时间复杂度:col+elements 
{ 
    /*
    思路:   先确定a矩阵中每一列的元素个数
            然后确定a矩阵转置为b矩阵之后的元素位置 
            下一行元素位置=上一行元素位置+元素个数 
            相当于先确定好每一个元素的位置后进行填充
    */ 
    int row_terms[MAX_COL],starting_pos[MAX_COL] 
    //转置后矩阵的行数，矩阵转置后的每一行的开始位置
    int i,j,num_cols=a[0].col,num_terms =a[0].values;//, , a阵的列数，a阵的最大元素数 
    b[0].row=a[0].col;
    b[0].col=a[0].row;
    b[0].value=num_terms;
    if(num_terms > 0){
        for(i=1;i<num_col;i++){
            //初始a阵的每一列元素个数为0 
            row_terms[i]=0;
        }
        for(i=1;i<num_terms;i++){
            //a阵求每一列元素个数 
            row_terms[a[i].col]++;
        } 
        starting_pos[0]=1;
        //开始位置为1--去除第一行记录矩阵总信息的行 
        for(i=1;i<num_col;i++){
            //每一行的开始位置=上一行的位置+上一行的元素数目 
            startint_pos[i]= startint_pos[i-1]+row_terms[i-1];
        } 
        for(i=1;i<num_terms;i++){
            //每次用完开始位置后要加1--因为有一个元素已经占有了那个开始位置 
            j=starting_pos[a[i].col]++; 
            b[j].row=a[i].col;
            b[j].col=a[i].row;
            b[j].value=a[i].value;    
        }
    } 
     
}