稀疏矩阵的乘法

注意：

    第二个矩阵最好要转置一下,因为开始时矩阵的行序号是排好了序的,而列没有,转置后就不同了,

    只要A矩阵和B和转置矩阵行跟行相乘就行了!

#include<iostream>
#include<cstring>
using namespace std;

struct term {
    int row;           //行，下标为0时指矩阵的行数
    int col;           //列，下标为0时指矩阵的列数
    int value;         //数值，下标为0时指矩阵的非零元素数
};

term
A[100] = { {3,4,6},{0,0,1},{0,2,2},{1,1,3},{1,3,4},{2,0,5},{2,2,6} },
B[100] = { {4,3,4},{0,0,1},{1,1,1},{2,2,1},{3,0,1} };

//插入元素到积矩阵
void storesum ( term d[ ], int *t, int row, int col, int *sum) {
    if( *sum ) {
        d[++*t].row = row;
        d[*t].col = col;
        d[*t].value = *sum;
        *sum = 0;
    }
}

//矩阵转置， x转置后得到new_b
void fast_transpose ( term x[ ], term new_b[ ] ) { //
    int strat[10];                 //转置后各行起始位置
    int row_terms[10];             //转置后的每行中非零元素的个数

    new_b[0].row = x[0].col;
    new_b[0].col = x[0].row;
    new_b[0].value = x[0].value;

    if( x[0].value > 0 ) {
        for( int i = 0; i < x[0].col; i++ )
            row_terms[i] = 0;
        for( int i = 1; i <= x[0].value; i++ )
            row_terms[x[i].col]++;
        strat[0] = 1;
        for( int i = 1; i < x[0].col; i++ )
            strat[i] = strat[i-1] + row_terms[i-1];
        for( int i = 1; i <= x[0].value; i++ ) {
            int j = strat[x[i].col]++;
            new_b[j].row = x[i].col;
            new_b[j].col = x[i].row;
            new_b[j].value = x[i].value;
        }
    }
}
//矩阵a乘于矩阵b得到矩阵d;
void mmult ( term a[ ], term b[ ], term d[ ] ) {
    term new_b[100];
    fast_transpose ( b, new_b );   //转置第二个矩阵
    int sum = 0;
    int t = 0;                     //d总的元素个数
    //下面几行只是为了第二个for循环多循环一次,以致得到最后的那个结果
    new_b[b[0].value+1].row = b[0].col;
    new_b[b[0].value+1].col = 0;
    new_b[b[0].value+1].value = 0;
    a[a[0].value+1].row = a[0].row;

    for( int i = 1; i <= a[0].value; ) {
        int row = a[i].row;
        int column = new_b[1].row;
        int row_begin = i;         //记录当前行最前的非零元素的位置

        for(int j = 1; j <= b[0].value+1; ) {
            if( a[i].row != row ) {//a矩阵往下一行了
                storesum ( d, &t, row, column, &sum );
                i = row_begin;     //行中第一个非0数
                for( ; new_b[j].row == column; j++ ); //a中的当前行非零元素已经没有的，而b中还有
                column = new_b[j].row; //指向下一个(下一列那个)元素
            } else if( new_b[j].row != column ) {  //非同列的不相乘
                storesum ( d, &t, row, column, &sum );
                i = row_begin;//a矩阵回到当前行的最前面一个非零元素，以致与new_b的下一行相乘
                column = new_b[j].row;//指向一个(下一列那个)元素
            } else {
                if( a[i].col < new_b[j].col ) i++;//不在同一列不相乘
                else if( a[i].col > new_b[j].col ) j++;//不在同一列不相乘
                else
                    sum += (a[i++].value * new_b[j++].value);
            }
        }
        for( ; a[i].row == row; i++ );//b中的当前行非零元素已经没有的，而a中还有；
    }
    d[0].row = a[0].row;  //行数
    d[0].col = b[0].col;  //列数
    d[0].value = t;       //非零元素数目
}
int main() {
    term d[100];          //积
    mmult( A, B, d );
    for(int i=0; i<=d[0].value; i++)
        cout<<d[i].row<<' '<<d[i].col<<' '<<d[i].value<<endl;
    cout<<endl;
    return 0;
}