【数据结构】稀疏结构及稀疏矩阵的压缩存储，矩阵的转置

在矩阵中，有一类很重要的矩阵，就是-----稀疏矩阵。

所谓的稀疏矩阵呢，就是指的是，在矩阵中，有效的数据个数远远小于无效的数据个数（并且这些数据排列顺序没有规律）。我们下面先举个稀疏矩阵的例子：

有效数据个数仅仅6个，其余都为无效数据0.

那我们将稀疏矩阵存在压缩矩阵中，设定一个三元组，使用{row,col,value}存储每一个有效数据，三元组按原矩阵中的位置，以行优先级先后顺序依次存放。

我们建立一个结构体：

struct Triple//定义一个三元组，用来存储稀疏矩阵的x,y,坐标值
{
    int _row;
    int _col;
    T _value;
};

将每一个有效数据（三元组）存在顺序表vector中，打印数据就按照顺序表的特点打印。

矩阵的转置：

所以，转置就是将原矩阵的行、列对换，也就是将[i][j]和[j][i]位置上的数据对换。

代码如下：

#include<vector>

template<class T>
struct Triple//定义一个三元组，用来存储稀疏矩阵的x,y,坐标值
{
    int _row;
    int _col;
    T _value;

    Triple(int row, int col, int value)
        :_row(row)
        , _col(col)
        , _value(value)
    {}
};

template<class T>
class SparseMatrix
{
public:
    SparseMatrix(T* a, int m, int n, const T& invalid)
        
    {
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (invalid != a[i*n+j])
                {
                         //将每一个有效数据（三元组）存在顺序表vector中
                    Triple <T> tmp(i, j, a[i*n + j]);
                    
                    _a.push_back(tmp);                    
                }
                
            }
        }    
    }

    //用坐标形式打印稀疏矩阵
    void Display(int m, int n, const T& invalid)
    {
        cout << "用坐标形式打印稀疏矩阵" << endl;
        cout <<"{" <<"x," << "  " << "y," << "  " << "value" <<"}" <<endl;
        for (int k = 0; k < _a.size(); k++)
        {
  
          cout << "{" << _a[k]._row << ",  " << 
_a[k]._col << ",  " << _a[k]._value << "  " << 
"}" << endl;
        }                                
    }

    //用矩阵形式打印稀疏矩阵
    void DisplayMatrix(int m, int n, const T& invalid)
    {        
        cout << "用矩阵形式打印稀疏矩阵" << endl;
        int k = 0;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {        
                
                if (k<_a.size()&&_a[k]._row == i && _a[k]._col == j)
                {
                    cout << _a[k]._value << "  ";
                    k++;
                }
                else
                {
                    cout << invalid << "  ";
                }                                
            }
            cout << endl;
        }
    }

    //矩阵转置
    SparseMatrix<T> Transport(T* a, int m, int n, const T& invalid)
    {
        cout << "矩阵转置：" << endl;
        int b[5][6];    //行列互换大小 
        for (int i = 0; i < m; i++)    //行列互换大小
        {
            for (int j = 0; j < n; j++)
            {
                    //将一维数组形式的元素转换为[j][i]形式
                b[j][i] = a[i*n + j];
            }        
        }
        
        SparseMatrix<T> TranMatrix((int*)b, 5, 6, 0);
        return TranMatrix;
    }

protected:
    vector <Triple <T>> _a;
    
};

void Test()
{

    int a[6][5] = {
                    { 1, 0, 3, 0, 5 },
                    { 0, 0, 0, 0, 0 },
                    { 0, 0, 0, 0, 0 },
                    { 2, 0, 4, 0, 6 },
                    { 0, 0, 0, 0, 0 },
                    { 0, 0, 0, 0, 0 },
                  }; 

    int m = 6;
    int n = 5;
    SparseMatrix<int> sm((int*)a, m, n, 0);
    sm.Display( m, n, 0);
    sm.DisplayMatrix( m, n, 0);
    SparseMatrix<int> sm1((int*)a, m, n, 0);
    sm1 = sm.Transport((int*)a, m, n, 0);

    
    sm1.Display( n, m, 0);
    sm1.DisplayMatrix(n, m, 0);
}

int main()
{
    Test();
    system("pause");
    return 0;
}