1.對稱矩陣

特點：
關於對角線對稱，Aij == Aji。
下面實現：
①對稱矩陣的壓縮儲存
②對稱矩陣的訪問
③對稱矩陣的還原

實現程式碼如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//對稱矩陣的壓縮儲存
template<class T>
class SymmetricMatrix
{
public:
    SymmetricMatrix(T* array, size_t N)
        :_N(N)
        ,_a(NULL)
    {
        _a = new
 
 T[(N * (N + 1))>> 1];
        for (size_t i = 0; i < N; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                if (i >= j)//表明是下三角資料時
                {
                    _a[(i * (i + 1))>>1 + j] = array[i * N + j];
                }
                else
 

                {
                    break;
                }
            }
        }
    }

    T& Access(size_t x, size_t y)
    {
        if (x < y)//如果訪問上三角元素
        {
            swap(x, y);
        }
        return _a[(x * (x + 1)) >> 1 + y];
    }

    void DisPlay()
    {
        for
 
 (size_t i = 0; i < _N; ++i)
        {
            for (size_t j = 0; j < _N; ++j)
            {
                if (i >= j)//訪問下三角元素
                {
                    cout<<Access(i, j)<<" ";
                }
                else
                {
                    cout << Access(j, i) << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
    }

    ~SymmetricMatrix()
    {
        if (_a)
        {
            delete[] _a;
            _a = NULL;
        }
    }

private:
    T* _a;
    size_t _N;
};

測試程式碼如下：

void Test()
{
    int a[5][5] =
    {
        { 0, 1, 2, 3, 4 },
        { 1, 0, 1, 2, 3 },
        { 2, 1, 0, 1, 2 },
        { 3, 2, 1, 0, 1 },
        { 4, 3, 2, 1, 0 },
    };
    SymmetricMatrix<int> sm((int*)a, 5);
    cout << sm.Access(0, 3) << endl;
    cout << sm.Access(3, 0) << endl;
    sm.DisPlay();
}

int main()
{
    Test();
    return 0;
}

2.稀疏矩陣：

(1)稀疏矩陣的壓縮儲存：

所謂稀疏矩陣的壓縮儲存，其實就是將稀疏矩陣中的有效元素儲存起來，但由於稀疏矩陣中有效元素的分佈沒有規律可尋，所以需要使用一個三元組來儲存其位置（row、col）以及有效值。—>三元組最好使用結構體來儲存。

因為不知道矩陣中究竟有多少個有效元素（即就是不知需要多少個結構體），那麼就可以使用vector（動態增長型）來儲存有效元素。

//三元組--->儲存有效元素的位置及值
    template<class T>
    struct Trituple
    {
        Trituple(size_t row, size_t col, const T& data)
        :_row(row)
        , _col(col)
        , _data(data)
        {}

        size_t _row;
        size_t _col;
        T _data;
    };

//稀疏矩陣的壓縮儲存
    SparseMatrix(T* array, int row, int col,const T& invalid)
        :_row(row)
        , _col(col)
        ,_invalid(invalid)
    {
        for (int i = 0; i < row; ++i)
        {
            for (int j = 0; j < col; ++j)
            {
                if (array[i * col + j] != invalid)
                {
                    _sm.push_back(Trituple<T>(i, j, array[i * col + j]));
                }
            }
        }
    }

(2)稀疏矩陣的轉置：

稀疏矩陣的轉置過程如下：

實現程式碼如下：

   // 稀疏矩陣的轉置
   //時間複雜度：(稀疏矩陣的列*稀疏矩陣中有效元素的個數)
    SparseMatrix<T> Transprot()
    {
        SparseMatrix<T> sm;
        sm._row = _col;
        sm._col = _row;

        for (size_t index = 0; index < _col; ++index)
        {
            vector<Trituple<T> >::iterator it = _sm.begin();
            while (it != _sm.end())
            {
                if ( it->_col == index)
                {
                    sm._sm.push_back(Trituple<T>(it->_col, it->_row, it->_data));
                }
                it++;
            }
        }
        return sm;
    }

3.稀疏矩陣的快速轉置：

稀疏矩陣的轉置的時間複雜度：(稀疏矩陣的列N*稀疏矩陣中有效元素的個數)—-》時間複雜度較大，所以引出了快速轉置

稀疏矩陣的快速轉置的時間複雜度（2*有效元素的個數 + 稀疏矩陣的列）

快速轉置的思想如下：

程式碼實現：

//快速轉置
SparseMatrix<T,N,M> FastTransport(const size_t m,const size_t n)
    {
    SparseMatrix < T, N, M> sm;//轉置後的壓縮矩陣
        sm._row = _col;
        sm._col = _row;
        sm._v.resize(_v.size());//為了保證後面可以直接訪問vector中的資料（呼叫operator[]）
        //儲存轉置前的每列有效元素的個數,即就是轉置後每行有效元素的個數
        int rows[N] = {0};
        size_t index = 0;
        while (index < _v.size())
        {
            rows[_v[index]._col]++;
            index++;
        }
        //儲存轉置後的每行第一個有效元素在轉置後的三元組陣列中的下標
        int starts[N] = { 0 };
        for (size_t i = 1; i < _col; ++i)
        {
            starts[i] = starts[i - 1] + rows[i - 1];
        }

        for (size_t i = 0; i < _v.size(); ++i)
        {
            int row = _v[i]._col;//轉置前列的下標即是轉置後行的下標
            Triple<T> t;
            t._value = _v[i]._value;
            t._col = _v[i]._row;
            t._row = _v[i]._col;
            sm._v[starts[row]] = t;
            starts[row]++;//每次需要更新starts陣列中的資料
        }
        return sm;
    }

全部程式碼如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<vector>

//三元組
template<class T>
struct Triple
{
    Triple()
    {}
    Triple(T& data, size_t row, size_t col)
        :_value(data)
        , _row(row)
        , _col(col)
    {}
    T _value;
    size_t _row;
    size_t _col;
};

template<class T,size_t M,size_t N>
class SparseMatrix
{
public:
    SparseMatrix()
    {}

    //稀疏矩陣的壓縮儲存
    SparseMatrix(T* array, const T& invalid)
        :_invalid(invalid)
        , _row(M)
        , _col(N)
    {
        for (size_t i = 0; i < _row; ++i)
        {
            for (size_t j = 0; j < _col; ++j)
            {
                if (array[i * N + j] != invalid)
                {
                    Triple<T> t;
                    t._value = array[i * N + j];
                    t._row = i;
                    t._col = j;
                    _v.push_back(t);
                }
            }
        }
    }

    //稀疏矩陣的還原
    void Display()
    {
        int index = 0;
        for (size_t i = 0; i < _row; ++i)
        {
            for (size_t j = 0; j < _col; ++j)
            {
                if (index < _v.size() && _v[index]._row == i && _v[index]._col == j)
                {
                    cout << _v[index]._value << " ";
                    index++;
                }
                else
                {
                    cout << _invalid << " ";
                }
            }
            cout << endl;
        }
        cout << endl;
    }

    //稀疏矩陣的轉置
    SparseMatrix<T,N,M> Transport()
    {
        SparseMatrix<T,N,M> _sm;//轉置後的
        _sm._invalid = _invalid;
        _sm._row = _col;
        _sm._col = _row;
        //按列查詢（轉置前的列優先即就是轉置後的行優先）
        for (size_t i = 0; i < _col; ++i)
        {
            size_t index = 0;
            while (index < _v.size())
            {
                if (_v[index]._col == i)
                {
                    Triple<T> t;
                    t._value = _v[index]._value;
                    t._row = _v[index]._col;
                    t._col = _v[index]._row;
                    _sm._v.push_back(t);
                }
                index++;
            }
        }
        return _sm;
    }

    template<class T, size_t N, size_t M>
    friend class SparseMatrix;

//快速轉置
SparseMatrix<T,N,M> FastTransport(const size_t m,const size_t n)
    {
    SparseMatrix < T, N, M> _sm;//轉置後的壓縮矩陣
        _sm._row = _col;
        _sm._col = _row;
        _sm._v.resize(_v.size());//為了保證後面可以直接訪問vector中的資料（使用operator[]）
        //儲存轉置前的每列有效元素的個數,即就是轉置後每行有效元素的個數
        int rows[N] = {0};
        size_t index = 0;
        while (index < _v.size())
        {
            rows[_v[index]._col]++;
            index++;
        }
        //儲存轉置後的每行第一個有效元素在轉置後的三元組陣列中的下標
        int starts[N] = { 0 };
        for (size_t i = 1; i < _col; ++i)
        {
            starts[i] = starts[i - 1] + rows[i - 1];
        }

        for (size_t i = 0; i < _v.size(); ++i)
        {
            int row = _v[i]._col;//轉置前列的下標即是轉置後行的下標
            Triple<T> t;
            t._value = _v[i]._value;
            t._col = _v[i]._row;
            t._row = _v[i]._col;
            _sm._v[starts[row]] = t;
            starts[row]++;//每次需要更新starts陣列中的資料
        }
        return _sm;
    }

private:
    vector<Triple<T> >  _v;
    T _invalid;
    size_t _row;
    size_t _col;
};

測試程式碼如下：

void Test()
{
    int array[6][5] = { 
    { 1, 0, 3, 0, 5 },
    { 0, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 0 },
    { 1, 0, 3, 0, 5 },
    { 0, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 0 },
    };
    SparseMatrix<int,6,5> sm((int*)array, 0);
    sm.Display();
    SparseMatrix<int,5,6> sm2 = sm.FastTransport(5,6);
    sm2.Display();
}

int main()
{
    Test();
    return 0;
}

由於能力有限，又是剛開始學習資料結構，難免會有思考的不正確或是不完善的地方，歡迎大家批評指正。。。