稀疏矩阵压缩存储与快速转置：软考数据结构高频考点精讲

如果你正在刷软考的数据结构真题，稀疏矩阵这个考点几乎每年都会出现，但它又很“低调”——很少单独考一整道大题，更多是作为1到3分的选择题，藏在软件设计师、程序员等信息类科目的上午卷里。很多人复习到这里会选择直接跳过，觉得“不就是一个二维数组嘛”，结果一遇到转置、压缩存储、十字链表的概念题就发懵。这篇正是软考备战系列的第十一篇，我把稀疏矩阵这个专题彻底讲透，从考法分布到三元组顺序表，再到快速转置的手算过程，全部按“真题怎么考我们就怎么练”的思路走一遍，帮你把这一块变成稳定的得分项。

1. 稀疏矩阵在软考数据结构中的位置

1.1 哪些科目考、占多少分

先明确一个前提：稀疏矩阵主要在软件设计师、程序员、数据库系统工程师等中级科目的上午题中出现，偶尔也会出现在系统分析师、系统架构师的综合知识里。就软件设计师而言，数据结构与算法部分大概占上午题的10到15分，稀疏矩阵虽然只占其中的1到3分，但属于“背了就会、不背就丢”的送分题。网络工程师、信息安全工程师中直接考察概率较低，但如果你考的是系统集成项目管理工程师这类偏管理的科目，这一块基本可以战略性放弃，重心放在项目管理知识上。

这里要提醒一点：软考上午题是75道选择题，及格线通常在45分左右。很多人总觉得大题才值得花时间，实际上上午题的1分同样决定成败。稀疏矩阵只要理解三元组和转置的思路，加半小时的真题练习，这几分基本稳拿，性价比相当高。

1.2 历年真题的典型考向

我翻过近五年的软件设计师真题，稀疏矩阵相关题目大致有四种问法。第一种，给一个具体的矩阵，要求写出它的三元组表，或者判断某个三元组是否正确。第二种，给定原矩阵的三元组表，让你求转置后的三元组表，这种题考的就是快速转置思想。第三种，对比不同存储方式的空间开销，比如问“如果一个100×100的矩阵非零元只有10个，用三元组存储比二维数组省多少空间”。第四种，判断题式考法，给出几个关于十字链表、稀疏因子的说法让你选出正确或错误的。

这些题本身难度都不大，难点在于很多考生平时只见过“完整矩阵”的存储方式，碰到稀疏矩阵就不知道怎么下手。实际上，你只需要掌握一个核心思想：只存非零元素的信息，同时记录它们的位置。接下来我们就沿着这个方向一层一层拆。

2. 稀疏矩阵到底在“稀疏”什么

2.1 稀疏因子与判断标准

稀疏矩阵是相对于普通矩阵而言的。如果一个矩阵里绝大多数元素都是0，只有极少数元素非零，那它就是稀疏矩阵。软考教材里给出了一个量化指标——稀疏因子δ，计算公式是：

δ = 非零元素个数 / 矩阵总元素个数 = t / (m × n)

当δ小于等于0.05时，通常可视为稀疏矩阵。也就是说，如果非零元素占比不超过5%，存储时就不值得再为那些0元素分配空间。举个例子，一个100×100的矩阵有10000个元素，如果非零元只有100个，δ=0.01，显然应该压缩存储。

但需要留意，这个0.05不是硬性规定，只是为了让你理解“稀疏”的比例概念。考试中如果给出一个矩阵让你判断是否稀疏，直接算比例即可，不用纠结边界值。

2.2 特殊矩阵与稀疏矩阵的区别

这是一个特别容易混淆的知识点。数据结构课程里还讲过对称矩阵、三角矩阵、对角矩阵，这些矩阵也常“压缩存储”，但它们的非零元素分布有规律，可以用数学公式把二维下标映射到一维数组下标。比如对称矩阵只用存上三角或下三角，定位某个元素时通过公式一步算出位置，时间复杂度O(1)。

稀疏矩阵则没有这种规律。100个非零元素可能分布在矩阵的任意角落，无法用统一公式定位，所以需要额外记录行列号。简单说，特殊矩阵的压缩靠“公式”，稀疏矩阵的压缩靠“记录位置”。

这个区别软考经常出概念题，表述往往很绕，比如“对称矩阵是稀疏矩阵的特殊情况”，这句话是错误的，因为对称矩阵的非零元素不一定少，它只是对称分布。如果你没有在备考初期把这两类存储分开，遇到判断题很容易被带偏。

2.3 压缩存储的整体思路

既然不存0元素，那非零元素怎么保存？最基本的方案是存三样东西：行号、列号、值。每个非零元素变成一个小结构体，多个结构体组成一个表，这就是三元组表。如果要动态插入删除元素，或者做矩阵乘加运算时非零元数量会变化，还可以用链式结构，也就是十字链表。

这里有一个全局性的认知：稀疏矩阵压缩存储的本质是“用时间换空间”。存储空间大幅减少，但访问一个元素时不能直接下标定位了，需要遍历查找，所以操作速度会变慢。软考中选择题如果问“压缩存储的缺点是增加了算法的时间复杂度”，这句话一般来说是对的。理解了这个代价，后面学转置算法时你就明白为什么会有“普通转置”和“快速转置”的区分了。

我建议你在笔记本上画一张表，把二维数组、三元组顺序表、十字链表三者的空间复杂度、能否快速定位、是否便于插入删除列成清单。这个整理过程本身就是对考点的一次深度消化。

3. 三元组顺序表：软考最高频的存储方案

3.1 三元组表的结构与定义

三元组顺序表是软考中最常见的稀疏矩阵存储方式。它的思路很直白：维护一个数组，数组里每个元素记录一个非零元素的行号、列号和值，同时再记录原矩阵的总行数、总列数、非零元总数。

用C语言结构体可以这样定义：

c复制typedef struct {
    int i, j;          // 非零元的行号、列号
    int value;         // 非零元的值
} Triple;              // 三元组

typedef struct {
    Triple data[MAXSIZE];  // 存放非零元素的三元组表
    int mu, nu, tu;        // 矩阵行数、列数、非零元个数
} TSMatrix;

其中，data[0]位置可以空闲不用，也可以存放特殊信息，不同教材定义不同。软考真题里如果用到数组下标，通常从1开始，但有的题目也会从0开始，做题时先看清楚题目给的是“下标从0开始”还是“下标从1开始”，这个细节决定了答案的差异。

三元组表按行优先存放，也就是先按行号从小到大排，行号相同时按列号从小到大排。为什么要有这个顺序？因为原矩阵本身是二维的，我们在读取矩阵时习惯按行扫描，按行优先存储三元组表，转置算法实现起来才更方便，也符合后续很多矩阵操作的遍历习惯。

3.2 普通转置为什么慢

转置是稀疏矩阵最常考的操作。矩阵转置就是把行列互换，原来的行变成新矩阵的列，原来的列变成新矩阵的行。对于完整矩阵，直接双重循环交换下标即可。但三元组表存储下，转置后必须仍然保持“行优先”的顺序，这就不能简单地把每个三元组里的i和j互换就完事。

先看一个容易出错的错误做法：把三元组中每个元素的i、j直接互换，然后不做任何排序。比如原三元组表按行优先是(1, 2, 3)、(2, 1, 4)，互换后变成(2, 1, 3)、(1, 2, 4)，结果第一个元素的行号大于第二个，破坏了转置矩阵的行优先要求，这个三元组表是错的。

普通转置算法的思路是：扫描原矩阵的每一列，在每次扫描中，遍历三元组表，找出所有列号等于当前列的记录，依次放入新表。因为外层循环按列从小到大，所以放入新表的元素自然按行优先排列。代码如下：

c复制void Transpose(TSMatrix M, TSMatrix *T) {
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu == 0) return;
    int q = 1;  // 新表当前位置，假设下标从1开始
    for (int col = 1; col <= M.nu; col++) {
        for (int p = 1; p <= M.tu; p++) {
            if (M.data[p].j == col) {
                T->data[q].i = M.data[p].j;
                T->data[q].j = M.data[p].i;
                T->data[q].value = M.data[p].value;
                q++;
            }
        }
    }
}

这个算法的时间复杂度是多少？外层循环是nu次，内层每次扫描tu个元素，所以是O(nu×tu)。如果矩阵特别大，非零元也不少，这个开销会很高。软考常在这里设陷阱，问你普通转置的时间复杂度，很多考生会直接答O(mu×nu)，这就是没理解三元组表的实际结构。记住，普通转置是O(nu×tu)，不是O(mu×nu)。

3.3 快速转置的核心思想

既然普通转置慢在需要反复扫描，我们能不能只扫描一次就得到结果？可以。快速转置的核心思路是提前计算好“原矩阵每一列的第一个非零元素在转置表中的存放位置”，然后扫描原三元组表时，直接把每个元素放到目标位置，放完一个位置就往后挪一位，不需要回头再查。

这里要引入两个辅助数组：num数组统计原矩阵每一列的非零元素个数，copt数组记录每一列第一个非零元素在新表中的起始位置。copt的递推公式是：

copt[1] = 1
copt[col] = copt[col - 1] + num[col - 1]

这个公式的意思是，某一列第一个元素应该放在它前面所有列的非零元素都放完之后的下一格。比如第1列有2个非零元，第2列有3个，那么第3列第一个非零元应该放在位置6，因为前两列共占了5个位置，6 = 1 + 2 + 3 - 1，公式里递推下来也正好是这个逻辑。

有了copt表，快速转置算法就变成：

c复制void FastTranspose(TSMatrix M, TSMatrix *T) {
    int num[MAXSIZE], copt[MAXSIZE];
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu == 0) return;
    // 第一步：统计每列非零元素个数
    for (int col = 1; col <= M.nu; col++) {
        num[col] = 0;
    }
    for (int p = 1; p <= M.tu; p++) {
        num[M.data[p].j]++;
    }
    // 第二步：计算每列第一个元素在新表中的起始位置
    copt[1] = 1;
    for (int col = 2; col <= M.nu; col++) {
        copt[col] = copt[col - 1] + num[col - 1];
    }
    // 第三步：扫描原三元组表，一次性放到目标位置
    for (int p = 1; p <= M.tu; p++) {
        int col = M.data[p].j;
        int q = copt[col];
        T->data[q].i = M.data[p].j;
        T->data[q].j = M.data[p].i;
        T->data[q].value = M.data[p].value;
        copt[col]++;  // 同一个列号的下一个元素紧挨着放
    }
}

注意第三步里有个关键操作：copt[col]++。因为同一列可能不止一个非零元，第一个放完后，第二个必须放在下一个位置，所以用完一次当前位置就把copt[col]加1。很多人在这一步漏掉自增，导致同一列元素全部写到同一个位置，结果自然不对。

时间复杂度方面，三步分别花费O(nu)、O(nu)、O(tu)，加起来是O(nu + tu)。在稀疏矩阵中tu远小于mu×nu，所以比普通转置的O(nu×tu)性能好很多。软考选择题如果问“快速转置比普通转置快在什么地方”，答案就是它避免了反复扫描三元组表，一次遍历定位完成。

4. 完整代码解读与手算演示

4.1 一个可直接运行的示例

光看伪代码不够，我用一个实际例子带你走一遍整个过程。假设有这样一个3×4矩阵：

code复制1  0  0  0
0  0  5  0
0  0  0  8

它的非零元素有3个。按行优先方式存储的三元组表（下标从1开始）为：

原矩阵mu=3，nu=4，tu=3。现在对它做快速转置。转置后目标矩阵应该是4×3的矩阵，非零元位置如下：

code复制转置矩阵（4行3列）：
(1, 1) = 1
(3, 2) = 5
(4, 3) = 8

按行优先的三元组表应为：(1,1,1)、(3,2,5)、(4,3,8)。

我们用算法来验证。第一步统计每列非零元个数num。原矩阵第1列有1个非零元，num[1]=1；第2列有0个，num[2]=0；第3列有1个，num[3]=1；第4列有1个，num[4]=1。

第二步算copt：copt[1]=1；copt[2]=copt[1]+num[1]=1+1=2；copt[3]=copt[2]+num[2]=2+0=2；copt[4]=copt[3]+num[3]=2+1=3。

第三步扫描原三元组表。第一个元素(1,1,1)，它的列号是1，所以q=copt[1]=1，放到转置表第1个位置，得到(1,1,1)，然后copt[1]变成2。第二个元素(2,3,5)，列号3，q=copt[3]=2，放到第2个位置，得到(3,2,5)，copt[3]变成3。第三个元素(3,4,8)，列号4，q=copt[4]=3，放到第3个位置，得到(4,3,8)，copt[4]变成4。

最终得到的三元组表和我们手工推出来的一致。你可以在草稿纸把这个过程完整写一遍，尤其是copt的变化，写几遍后基本就能记住整个算法的脉络，考试时选择题哪怕不写代码，也能快速判断某个元素应该放在哪个位置。

4.2 真题模拟：如何快速判断转置后的某元素位置

有一种高频考题是这样的：给定原矩阵三元组表和某个非零元的行列，问转置后这个元素排在第几位。有了copt数组的思想，这类题可以直接心算。

还是上面的矩阵，问你原矩阵中(2,3)位置的值5，转置后排在第几个位置。方法很简单：转置后它变成(3,2)，在转置矩阵中，按行优先看，行号3前面有行号1和行号2。行号1只有一个非零元(1,1)，行号2没有非零元，所以它前面只有1个元素，排名第2。这种思路在做选择题时比写完整算法更快。

注意，如果题目给的是完整的矩阵而不是三元组表，你需要先分析原矩阵各行的非零元分布。其实本质就是在模拟copt的计算，只是不显式写出数组。

5. 十字链表与其他存储方案的必要补充

5.1 十字链表的结构与适用场景

三元组表虽然存储紧凑，但它是顺序存储，插入或删除一个非零元素时，需要移动大量数据。比如矩阵乘法运算中，新矩阵的非零元个数事先无法确定，如果还用三元组表，可能需要反复扩容、插入、移动，效率很低。这时就要用到十字链表。

十字链表是稀疏矩阵的链式存储方案。它把矩阵的每一行串成一个行链表，每一列串成一个列链表。每个非零元素结点除了存行号、列号和值，还有两个指针域：right指向同一行的下一个非零元，down指向同一列的下一个非零元。光看名字很抽象，但你想象一下“十字”两个字，每个结点既横着连在行链表上，又竖着连在列链表上，横竖交叉，所以叫十字链表。

结构体可以这样定义：

c复制typedef struct OLNode {
    int i, j;
    int value;
    struct OLNode *right, *down;
} OLNode;

typedef struct {
    OLNode *rhead[MAXSIZE];  // 行链表头指针数组
    OLNode *chead[MAXSIZE];  // 列链表头指针数组
    int mu, nu, tu;
} CrossList;

软考对十字链表的考察通常停留在“识别”层面。比如给一个十字链表的示意图，问某个结点的right和down分别指向哪里，或者问下列哪种操作适合用十字链表实现。你只需要掌握两个要点：一是结点的right指向同行下一个非零元，down指向同列下一个非零元；二是十字链表适合非零元个数经常变化、需要频繁插入删除的场景。

5.2 行逻辑链接顺序表：乘法专用方案

除了三元组表和十字链表，软考教材里还会提到一种“带行链接信息的三元组表”，也叫行逻辑链接顺序表。它本质上还是三元组顺序表，只是额外维护一个rpos数组，rpos[i]记录第i行的第一个非零元在三元组表data中的下标位置。

这样设计是为了高效实现稀疏矩阵乘法。做乘法时，需要快速找到某一行的所有非零元，如果每次都要从data开头遍历，代价太高。有了rpos数组，直接定位到该行第一个元素的位置，然后往下读到下一行开始之前，就是这一行的全部非零元。

这种存储方式在考试中出现的频率比十字链表更低，通常是结合矩阵乘法的大题出现。我建议你把rpos的概念理解清楚即可，不必深究代码级别的实现。

5.3 存储方案横向对比

为了帮你应对概念判断题，我把几种存储方案的核心参数整理成了一张表，考前可以反复看。

如果你能在脑海中复现这张表，考试中遇到“下列说法错误的是”这类题，基本能快速排除错误选项。

6. 常见问题与排查技巧实录

6.1 高频失分点速查表

我在刷题和带新人备考的过程中，总结了六个最常见错误，这些也是软考真题里反复挖坑的地方。

除表格里的问题，还有一个隐蔽错误：普通转置的时间复杂度。很多人想当然地认为转置是行列互换，复杂度应该是O(mu×nu)，但三元组方式下由于要反复扫描，复杂度变成了O(nu×tu)。遇到时间复杂度对比题，优先从算法的遍历次数去推导，不要凭直觉作答。

6.2 复习建议与刷题策略

关于稀疏矩阵，我不建议抱着教材从头啃到尾。更有效的路径是“先做题，再反查知识点”。你可以把近五年的软件设计师上午真题中涉及稀疏矩阵的题目全部找出来，大概15到20道，用半小时做完，然后对照错题去找知识点漏洞。这个方法的效率比先看书再做题高很多，因为考点非常集中，刷完这些题你就能摸清出题人的套路。

如果身边有一起备考的朋友，可以互相出题考“快速转置后某元素位置”。这种互动式记忆比一个人死记硬背更有用。我备考时常用这个办法，效果相当不错。需要注意，软考下午题中一般不会单独考稀疏矩阵的代码题，但每年可能有涉及，主考案例分析时可能会把三元组作为某个算法的小问，所以也不要完全放弃代码层面的理解。

最后给你一个非常实用的备考小技巧：在草稿纸上手画一个5×5的非零矩阵，自己动手写出三元组表，再手动转置一次。这大概只需要10分钟，但比你反复看十遍教材都有用。手写过程会让你的大脑真正理解行列交换的含义，而不是停留在“背代码”的层面。

我个人的体会是，稀疏矩阵这个考点最大的特点就是“看起来难，实际简单”。很多人在考场上丢掉这几分，不是因为不会，而是因为没有系统读过一遍相关的存储定义和转置算法，心里没底。你可以按这篇的思路梳理一遍，再做几道真题，下次遇到它基本就是送分题了。