稀疏矩阵

SparseMatrix

存储：

使用三元表存储，即结构体数组

struct element
{
　　int row, col;//元素item在矩阵中的位置
　　T item;
};

矩阵转置方法：A->B（A按行存储，要求转置得到的矩阵按列存储）

1、直接取，顺序存

　　从左到右，上到下进行存储

2、顺序取，直接存

　　计算每一列的元素数目和每一列非零元素的位置上

for (i = 0; i<A.tu; i++) //遍历A的所有元素
        {
            j = A.data[i].col;//三元表A的元素i的列号
            k = cpot[j];//k为待存元素在B中的位置
            B.data[k].row = A.data[i].col;
            B.data[k].col = A.data[i].row;
            B.data[k].item = A.data[i].item;
            cpot[j]++;//A中记录在cpot中的每一列非零元素改变
        }

以列号j=4做示范：

　　当一个元素的列满足要求时，得到k = cpot[j], k为B的三元表中待存位置，然后cpot[j]++，使下一个同列元素存在其下

 

 

//稀疏矩阵
#include <iostream>

using namespace std;
const int MAXTERM = 100;//三元表最长长度

template<class T>
struct element
{
    int row, col;//元素item在矩阵中的位置
    T item;
};

template<class T>
class SparseMatrix
{
public:
    SparseMatrix() {}
    //有参数的构造函数
    SparseMatrix(int intmu, int intnu, int inttu, element<T> datatemp[]);
    ~SparseMatrix() {}//释放空间
    element<T> GetMatrix(int intnumber);//输出对应下标下的数组元素【索引值】
    void Prt();//打印三元组顺序表
    void Trans1(SparseMatrix<T> &B);//矩阵的转置，直接取，顺序存
    void Trans2(SparseMatrix<T> A, SparseMatrix<T> &B);//矩阵的转置，顺序取，直接存
private:
    element<T>data[MAXTERM];
    int mu, nu, tu;//矩阵的行，列，不同元素个数
};

int _tmain(int argc, _TCHAR* argv[])
{
    try {
        element<int> elementtemp1, elementtemp2, elementtemp3;
        elementtemp1.col = 0, elementtemp1.row = 0, elementtemp1.item = 15;
        elementtemp2.col = 1, elementtemp2.row = 2, elementtemp2.item = 16;
        elementtemp3.col = 1, elementtemp3.row = 0, elementtemp3.item = 17;
        //(0,0),(0,1),(2,1)
        element<int> A[3];
        A[0] = elementtemp1, A[1] = elementtemp2, A[2] = elementtemp3;

        SparseMatrix<int> sparsematrixB;
        SparseMatrix<int> sparsematrixA(3, 3, 3, A);

        cout << "源三元组顺序表如下：" << endl;
        sparsematrixA.Prt();
        sparsematrixA.Trans1(sparsematrixB);
        cout << "使用直接取、顺序存转置算法转置后的三元组顺序表如下：" << endl;
        sparsematrixB.Prt();
        sparsematrixA.Trans2(sparsematrixA, sparsematrixB);
        cout << "使用顺序取、直接存转置算法后的三元组顺序表如下：" << endl;
        sparsematrixB.Prt();
    }
    catch (char *s)
    {
        cout << s << endl;
    }
    system("pause");
    return 0;
}

template<class T>
SparseMatrix<T>::SparseMatrix(int intmu, int intnu, int inttu, element<T> datatemp[])
{
    if (inttu>MAXTERM)
        throw"构造函数的初始化参数不正确";
    mu = intmu, nu = intnu, tu = inttu;
    for (int i = 0; i<inttu; i++)
        data[i] = datatemp[i];
}

template<class T>
element<T> SparseMatrix<T>::GetMatrix(int intnumber)
{
    if (intnumber<0 || intnumber >= tu)
        throw"输入位置不正确";
    return data[i];
}

template<class T>
void SparseMatrix<T>::Prt()
{
    for (int i = 0; i<tu; i++)
        cout << "row:" << data[i].row << ",col:" << data[i].col << ",item:" << data[i].item << endl;
}



template<class T>//待转置的源三元组顺序表A和目标三元顺序表B的引用
void SparseMatrix<T>::Trans1(SparseMatrix<T> &B)
{
    int pb;
    B.mu = nu, B.nu = mu, B.tu = tu;

    if (B.tu>0)
    {
        pb = 0;
        for (int col = 0; col < nu; col++)
            for (int i = 0; i < tu; i++)
                if (data[i].col == col)
                {
                    B.data[pb].row = data[i].col;
                    B.data[pb].col = data[i].row;
                    B.data[pb++].item = data[i].item;
                }
    }
}

template<class T>
void SparseMatrix<T>::Trans2(SparseMatrix<T> A, SparseMatrix<T> &B)
{
    B.mu = A.nu, B.nu = A.mu, B.tu = A.tu;
    int i, j, k, num[MAXTERM], cpot[MAXTERM];
    if (B.tu > 0)
    {
        for (i = 0; i<A.nu; i++)
            num[i] = 0;//A中每一列的非零个数，初始化为0
        for (i = 0; i<A.tu; i++)
        {
            j = A.data[i].col;
            num[j]++;//得到A每一列的元素数，得到num[i]
        }
        cpot[0] = 0;//A中第0列中第一个元素在B的三元表中位置为0
        for (i = 1; i<A.nu; i++)
            cpot[i] = cpot[i - 1] + num[i - 1];//求A中第i列第一个非零元素在B的三元表中的下标

        for (i = 0; i<A.tu; i++)
        {
            j = A.data[i].col;//三元组元素i的列号
            k = cpot[j];//A中第j列的非零元素的下标【行号】
            B.data[k].row = A.data[i].col;
            B.data[k].col = A.data[i].row;
            B.data[k].item = A.data[i].item;
            cpot[j]++;//A中第j列的非零元素下标【行号】下移
        }
    }
}