稀疏矩阵的压缩存储

实现稀疏矩阵压缩存储，并实现矩阵转置和求和。

输入矩阵时，首先需要输入非零元素的个数，然后分别输入矩阵的 行号，列号和值。

输完2个矩阵后，自动进行计算第一个矩阵的转置以及两个矩阵的和。

例如：输入如下：

100 90 5 //矩阵的行数为100，列数为90，共5个非零元素。
1 10 100 //a(1,10)=100
50 60 200//a(50,60)=200 
50 80 100//a(50,80)=100 
60 60 200//a(60,60)=200 
99 89 10//a(99,89)=10 
100 90 4 //矩阵b的行数为100，列数为90，共4个非零元素。 
1 1 10 //b(1,1)=10 
50 60 -200//b(50,60)=-200 
50 80 100 //b(50,80)=100 
70 70 10 //b(70,70)=10

上代码：

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

struct Trituple
{
    int row,col,value;
    Trituple&operator = (Trituple&x)
    {
        row = x.row;
        col=x.col;
        value=x.value;
    }
};
class SparseMatrix
{
    friend ostream&operator<<(ostream&out,SparseMatrix&M);
    friend istream&operator>>(istream&in,SparseMatrix&M);
public:
    SparseMatrix(SparseMatrix&x);
    SparseMatrix(int maxSz=100);

    SparseMatrix Transpose();              //矩阵转置
    SparseMatrix Add(SparseMatrix &b);     //当前矩阵与b相加
private:
    int Rows,Cols,Terms;
    Trituple *smArray;
    int maxTerms;
};

ostream& operator << (ostream& out, SparseMatrix&M)
{


    for(int i=0; i<M.Terms; i++)
        if(M.smArray[i].value!=0)
            out<<M.smArray[i].row<<" "<<M.smArray[i].col<<" "<<M.smArray[i].value<<endl;
    return out;
};
istream&operator>>(istream&in,SparseMatrix&M)
{


    in>>M.Rows>>M.Cols>>M.Terms;
    for(int i=0; i<M.Terms; i++)
    {
        in>>M.smArray[i].row>>M.smArray[i].col>>M.smArray[i].value;
    }
    return in;
}
SparseMatrix::SparseMatrix(SparseMatrix&x)//构造函数1
{
    Rows=x.Rows;
    Cols=x.Cols;
    Terms=x.Terms;
    maxTerms=x.maxTerms;
    smArray=new Trituple[maxTerms];
    for(int i=0; i<Terms; i++)
    {
        smArray[i]=x.smArray[i];
    }
};
SparseMatrix::SparseMatrix(int maxSz):maxTerms(maxSz)//构造函数2
{

    smArray=new Trituple[maxSz];
    Rows=Cols=Terms=0;
};
SparseMatrix SparseMatrix::Transpose()
{
    SparseMatrix b(maxTerms);
    b.Rows=Cols;
    b.Cols=Rows;
    b.Terms=Terms;
    if(Terms>0)
    {
        int k,i,CurrentB=0;
        for(k=0; k<Cols; k++)
            for(i=0; i<Terms; i++)
                if(smArray[i].col==k)
                {

                    b.smArray[CurrentB].row=k;
                    b.smArray[CurrentB].col=smArray[i].row;
                    b.smArray[CurrentB].value=smArray[i].value;
                    CurrentB++;

                }
    }
    return b;
}
SparseMatrix SparseMatrix:: Add(SparseMatrix &b)
{
    SparseMatrix Result;//(Rows,Cols,Terms);
    int i=0,j=0,index_a,index_b;
    Result.Terms=0;
    while(i<Terms&&j<b.Terms)
    {
        index_a=Cols*smArray[i].row+smArray[i].col;
        index_b=Cols*b.smArray[j].row+b.smArray[j].col;
        if(index_a<index_b)
        {
            Result.smArray[Result.Terms]=smArray[i];
            i++;
        }
        else if(index_a>index_b)
        {
            Result.smArray[Result.Terms]=b.smArray[j];
            j++;
        }
        else
        {
            Result.smArray[Result.Terms]=smArray[i];
            Result.smArray[Result.Terms].value=smArray[i].value+b.smArray[j].value;
            i++;
            j++;
        }
        Result.Terms++;

    }
    for(; i<Terms; i++)
    {
        Result.smArray[Result.Terms]=smArray[i];
        Result.Terms++;
    }
    for(; j<b.Terms; j++)
    {
        Result.smArray[Result.Terms]= b.smArray[i];
        Result.Terms++;
    }
    return Result;
}
int main()
{
    SparseMatrix a,b,c,d;
    cin>>a>>b;

    c=a.Transpose();
    d=a.Add(b);
    cout <<"The transformed matrix  is:"<<endl<< c ;
    cout <<"The added matrix is:"<<endl<<d ;
    return 0;
}