数据结构学习笔记--稀疏矩阵的压缩存储

 

先简单介绍一下概念。设一个m行n列的矩阵具有n个值不等于零的元素，则称t/(m*n)为该矩阵的稀疏因子。通常称稀疏因子小于0.5的矩阵为稀疏矩阵(sparse matrix)。

由于零元素较多，再使用通常的2维数组表示会造成存储空间的浪费，同时在计算时所有零元也要参与运算，导致效率很低。所以有必要研究如何存储稀疏矩阵，即压缩存储。书上这里介绍了3种存储方式，其实第二种行链接的方式是顺序存储的改进方法，二者可以归到一起。由于前两种存储方式实现起来非常简单，书上讲得很细，这里就不啰嗦了，下面主要介绍第三种实现：十字链表。

十字链表是这样构成的：用链表模拟矩阵的行（或者列，这可以根据个人喜好来定），然后再构造代表列的链表，将每一行中的元素节点插入到对应的列中去。打个比方吧：这个十字链表的逻辑结构就像是一个围棋盘（没见过，你就想一下苍蝇拍，这个总见过吧），而非零元就好像是在棋盘上放的棋子，总共占的空间就是，确定那些线的表头节点和那些棋子代表的非零元节点。最后，我们用一个指针指向这个棋盘，这个指针就代表了这个稀疏矩阵。

现在，让我们看看非零元节点最少需要哪几个域，val是必须的，为了把线画下去还要有down、right，好像不需要别的了。但为了提高加法与乘法的效率，还要在每个节点增加两个值row,col分别表示节点所在的行、列。再看看表头节点，由于是链表的表头节点，所以就和后边的节点一样了。然后，行链表和列链表的表头节点实际上也各构成了一个链表。最后，我们只需要存储两个分别指向行表头与列表头节点的指针，就可以访问稀疏矩阵了。具体表示如下图：

 

为了能随机访问任意一行或一列，这里将头结点存放在一维数组中。下面是节点的定义：

 

class OLNode {
public:
    int row,col,val;
    OLNode* right;
    OLNode* down;
    OLNode(int i = 0, int j = 0, int v = 0,
        OLNode* rgt = NULL, OLNode* dwn = NULL)
        : row(i), col(j), val(v), right(rgt), down(dwn) {}
    friend std::ostream& operator<<(std::ostream& os,
        OLNode& eom)
    {
        os << "(" << eom.row << "," << eom.col
            << "," << eom.val << ")";
        return os;
    }
};

 

下边会依次介绍矩阵的转置、加法和乘法，但在这之前先来设计一下类的输出输出接口，一个好的接口能为接下来的运算提供许多方便。除了通常的重载>>与<<之外，为了乘法实现的简便还需要重载=，这在下面会看到：

 

class SMatrix_OL {
    int maxRows, maxCols, total;
    OLNode* pRowHead;
    OLNode* pColHead;
    void initialize() {
        maxRows = maxCols = total = 0;
        pRowHead = pColHead = NULL;
    }
    void clear();
    void copy(const SMatrix_OL& sm);
    friend const SMatrix_OL 
        vectorMultiply(OLNode* colVector, OLNode* rowVector, 
        int rows, int cols);
public:
    SMatrix_OL() { initialize(); }
    //初始化一个i行j列的零矩阵
    SMatrix_OL(int i, int j) {
        require(i > 0 && j > 0, 
            "SMatrix_OL::SMatrix illegal matrix!");
        maxRows = i;
        maxCols = j;
        total = 0;
        pRowHead = new OLNode[maxRows + 1];
        pColHead = new OLNode[maxCols + 1];
    }
    SMatrix_OL(const SMatrix_OL& sm) {
        copy(sm);
    }
    SMatrix_OL& operator=(const SMatrix_OL& sm) {
        if (maxRows) clear();
        copy(sm);
        return *this;
    }
    ~SMatrix_OL() {
        clear();
    }
    friend std::ostream& operator<<(std::ostream& os, 
        const SMatrix_OL& sm) {
        for (int i = 1; i <= sm.maxRows; i++) {
            OLNode* p = sm.pRowHead[i].right;
            if (i == 1)
                os << "/";
            else if (i == sm.maxRows)
                os << "/";
            else os << "|";
            for (int j = 1; j <= sm.maxCols; j++) {
                int val;
                if (p == NULL || p->col > j)
                    val = 0;
                else {
                    val = p->val;
                    p = p->right;
                }
                os.setf(std::ios::right, std::ios::adjustfield);
                os.width(4);
                os << val;
            }
            os.setf(std::ios::right, std::ios::adjustfield);
            os.width(4);
            if (i == 1)
                os << "/";
            else if (i == sm.maxRows)
                os << "/";
            else os << "|";
            os << std::endl;
        }
        return os;
    }
    friend std::istream& operator>>(std::istream& is,
        SMatrix_OL& sm) {
        cout << "创建稀疏矩阵：" << endl;
        cout << "输入行数、列数和非零元个数：" << endl;
        is >> sm.maxRows >> sm.maxCols >> sm.total;
        require(sm.maxRows > 0 && sm.maxCols > 0 && sm.total >= 0,
            "SMatrix_OL::operator>> illegal input!");
        sm.pRowHead = new OLNode[sm.maxRows + 1];
        sm.pColHead = new OLNode[sm.maxCols + 1];
        for (int n = 1; n <= sm.total; n++) {
            cout << "输入第" << n << "个非零元：" << endl;
            int i, j, val;
            is >> i >> j >> val;
            require(i > 0 && j > 0,
                "SMatrix_OL::operator>> illegal input!");
            OLNode* pNew = new OLNode(i, j, val);
            OLNode* prior = &sm.pRowHead[i];
            while (prior->right != NULL && prior->right->col < j)
                prior = prior->right;
            pNew->right = prior->right;
            prior->right = pNew;//行链接完毕
            prior = &sm.pColHead[j];
            while (prior->down != NULL && prior->down->row < i)
                prior = prior->down;
            pNew->down = prior->down;
            prior->down = pNew;//列链接完毕
        }
        cout << "稀疏矩阵创建完毕！" << endl;
        return is;
    }
};
void SMatrix_OL::clear() {
        for (int i = 1; i <= maxRows; i++) {
            if (pRowHead[i].right == NULL) continue;
            OLNode* p = pRowHead[i].right;
            //删除当前行的所有结点
            while (p != NULL) {
                OLNode* q = p;
                p = p->right;
                delete q;
            }
        }
        delete []pRowHead;
        delete []pColHead;
}
void SMatrix_OL::copy(const SMatrix_OL& sm) {
        maxCols = sm.maxCols;
        maxRows = sm.maxRows;
        total = sm.total;
        pRowHead = new OLNode[maxRows + 1];
        pColHead = new OLNode[maxCols + 1];
        OLNode** pUpNode = new OLNode*[maxCols + 1];
        for (int n = 1; n <= maxCols; n++)
            pUpNode[n] = &pColHead[n];
        for (int i = 1; i <= maxRows; i++) {
            if (sm.pRowHead[i].right == NULL) continue;
            OLNode* prior = &pRowHead[i];
            OLNode* pOld = sm.pRowHead[i].right;
            while (pOld != NULL) {
                OLNode* pCopy = new 
                    OLNode(i, pOld->col, pOld->val);
                prior = prior->right = pCopy;
                pUpNode[pOld->col] = 
                    pUpNode[pOld->col]->down = pCopy;
                pOld = pOld->right;
            }
        }
}

 

这些都是很常规的实现，不再细说了。首先是转置运算，如果按照一般的方法需要在转置的同时改动很多指针的指向，比较麻烦，这里使用的方式是先把矩阵复制一个临时副本，然后清除原来的矩阵，再以列序从副本复制回来，则现在的矩阵就是原来的转置。代码如下：

 

//先把自己复制给sm，然后把自己构造成sm的转置
void Transpose() {
    SMatrix_OL sm = *this;
    clear();
    maxRows = sm.maxCols;
    maxCols = sm.maxRows;
    total = sm.total;
    pRowHead = new OLNode[maxRows + 1];
    pColHead = new OLNode[maxCols + 1];
    OLNode** pUpNode = new OLNode*[maxCols + 1];
    for (int n = 1; n <= maxCols; n++)
        pUpNode[n] = &pColHead[n];
    for (int j = 1; j <= sm.maxCols; j++) {
        if (sm.pColHead[j].down == NULL) continue;
        OLNode* prior = &pRowHead[j];
        OLNode* pOld = sm.pColHead[j].down;
        while (pOld != NULL) {
            OLNode* pNew = new OLNode(j, pOld->row, pOld->val);
            prior = prior->right = pNew;
            pUpNode[pNew->col] = 
                pUpNode[pNew->col]->down = pNew;
            pOld = pOld->down;
        }
    }
}
const SMatrix_OL operator~() {
    SMatrix_OL sm = *this;
    sm.Transpose();
    return SMatrix_OL(sm);
}
friend const SMatrix_OL 
    operator+(const SMatrix_OL& smA, const SMatrix_OL& smB) {
    require(smA.maxRows == smB.maxRows && 
        smA.maxCols == smB.maxCols,
        "SMatrix_OL::operator+ cannot add!");
    SMatrix_OL smC = smA;
    smC.Add(smB);
    return SMatrix_OL(smC);
}

 

OK，该本篇文章的压轴算法出场了^_^那就是乘法，书上根本就没有提到十字链表的乘法，原因就是太麻烦了。你想啊，每个节点有两个指针域，而且在做乘法运算时一个矩阵是按行访问，另一个是按列访问，乘积矩阵中的每一个元素都是一行与一列的乘积。我做到这里时头都大了，于是我又想能不能换一种方式：如果矩阵A是行矢量，矩阵B是列矢量，那么A*B很好实现。而一个普通的矩阵可以分解成由子矩阵组成的矢量，所以把A变成行矢量，把B变成列矢量，那么乘积矩阵可由n个子矩阵相加组成，其中n等于A的列数（或B的行数）。见下图：

 

这样一来，乘法就容易实现了：

friend const SMatrix_OL 
    operator*(const SMatrix_OL& smA, const SMatrix_OL& smB) {
    require(smA.maxCols == smB.maxRows, 
        "SMatrix_OL operator* cannot mult!");
    SMatrix_OL smC(smA.maxRows, smB.maxCols);
    //smC = A1*B1+A2*B2+...+An*Bn,n=smA.maxCols=smB.maxRows
    for (int n = 1; n <= smA.maxCols; n++)
        smC.Add(
            vectorMultiply(
            smA.pColHead[n].down, 
            smB.pRowHead[n].right, 
            smA.maxRows, smB.maxCols));
    return SMatrix_OL(smC);
}

其中的核心就是私有成员函数vectorMultiply，将两个矢量相乘，其实现也很简单：

const SMatrix_OL 
        vectorMultiply(OLNode* colVector, 
        OLNode* rowVector, int rows, int cols) 
{
    SMatrix_OL sm(rows, cols);
    if (colVector != NULL && rowVector != NULL) {
        OLNode** pUpNode = new OLNode*[sm.maxCols + 1];
        for (int n = 1; n <= sm.maxCols; n++)
            pUpNode[n] = &sm.pColHead[n];
        //行、列矢量相乘
        for (; colVector != NULL; colVector = colVector->down) {
            OLNode* prior = &sm.pRowHead[colVector->row];
            for (OLNode* pCur = rowVector; 
                pCur != NULL; pCur = pCur->right) 
            {
                OLNode* pNew = new 
                    OLNode(colVector->row, 
                    pCur->col, colVector->val * pCur->val);
                prior = prior->right = pNew;
                pUpNode[pNew->col] = 
                    pUpNode[pNew->col]->down = pNew;
                sm.total++;
            }
        }
    }
    return SMatrix_OL(sm);
}

 

下面该测试了，这里同样使用了sstream文件，其功能在上一篇文章已经说过了。

 

#include "SMatrix.h"
#include <iostream>
#include <sstream>
using namespace std;
int main() {
    stringstream input("
        3 2 6 
        1 1 1 1 2 2 2 1 3 2 2 4 3 1 5 3 2 6 
    ");
    SMatrix_OL A;
    input >> A;
    cout << "A =" << endl << A;
    SMatrix_OL B = A;
    cout << "B =" << endl << B;
    cout << "A + B =" << endl << A + B;
    cout << "B's transpose matrix = " << endl << ~B;
    cout << "A * ~B =" << endl << A * ~B;
    return 0;
}

 

可以看出，重载了一些符号之后使得矩阵的运算与内部类型就很相似了，下面是运行结果：

 

 

好了，第五章到此就结束了。本来后面还有广义表，但由于最近时间比较紧张就不打算再写了。这篇文章也是很匆忙地写完的，总觉得有些仓促，以后有时间会再修改一下，毕竟十字链表不比前几章学过的线性表，在实现上要复杂一些，包括下一节的广义表也是。虽然这部分内容不是重点，但我觉得系统地学习一下还是有好处的，可以为后面学习树打下基础，因为树的大部分运算都是递归的，并且其中的二叉树与十字链表一样有两个指针域。下一篇开始介绍第六章--树，也就是数据结构这门课程最重要的章节~预计分3篇文章，如果时间足够的话可能会把广义表补上，但广义表我又是在想不出一个好的应用，只写基本操作也没什么意思，到时候再说吧，呵呵~

最后说几句题外话，最近忙主要是因为把精力都花在学外语上了。这个星期是我们学校的英语周，从美国来了10多个老外，每天晚上都有讲座或者是娱乐活动。我每天下午都会去找他们聊天，练习口语，感觉这个星期收获很大，刚开始的时候只能一个词一个词的往外蹦，现在进本上能一段一段的说了！并且与一个叫Christ的老头儿交上了朋友，今天我去送得他，还送给他一个自己做得小礼物。老外很有意思，他们和你说话时面部表情特别丰富，还是不是加上许多肢体动作，让人感觉很亲切，呵呵~