数据结构与算法（C语言）代码实现-稀疏矩阵压缩与解压缩的代码实现（三元组存储法）

稀疏矩阵：在矩阵中,如果数值为0的元素数目远远多于非0元素的数目,并且非0元素分布无规律时,则称该矩阵为稀疏矩阵;

我们可以把稀疏矩阵理解成棋盘和棋子，棋盘上的点位很多，而下的棋子只有几个，要是我们想要实现存储棋盘的棋子点位，直接存的话就会有很多的空点位，存储这些空点位是很浪费空间且没有意义的，所有我们应该只存储有棋子的点位。这里我使用的是三元组存储法，即每一个棋子的点位用一个三元组来表示，三元组第一个值为棋子所在行，三元组的第二个值为棋子所在列，三元组的第三个值为棋子的值（比如说是小兵还是炮、车）

现有一个6×10的稀疏矩阵（其实非0元素有10个），用C语言来实现稀疏矩阵的压缩与解压缩，这里使用的是三元组存储压缩法。

压缩、解压缩结果截图：

代码实现：

//
// Created by wtk on 22-12-1.
//
#include <stdio.h>

/**
 * 稀疏数组压缩-三元组压缩法：只存储非0元素的 [所在行, 所在列, 非0值]9
 * @param sparse_array
 * @param compression_result
 */
void sparse_array_compression(int sparse_array[6][10], int compression_result[][3]){
    //compression_result的第一行存储稀疏数组的行数，列数，非0元素个数
    compression_result[0][0] = 6;
    compression_result[0][1] = 10;

    //从1开始
    int index = 1;
    //从每一行依次遍历每一个元素
    for(int row = 0; row < 6; row++){
        for(int column = 0; column < 10; column++){
            //获取当前元素的
            int value = sparse_array[row][column];
            //判断是不是非0元素
            if(value != 0){
                //存储元素所在行
                compression_result[index][0] = row + 1;
                //存储元素所在列
                compression_result[index][1] = column + 1;
                //存储元素的值
                compression_result[index][2] = value;
                //更新是第几个非0元素
                index++;
            }
        }
    }
    //存储稀疏数组的非0元素个数
    compression_result[0][2] = index-1;
    //打印压缩结果
    printf("压缩结果：\n{");
    for(int i = 1; i <= index; i++){
        //发现存储的行值为空，说明已经没有非0元素了
        if(compression_result[i][0] == 0){
            break;
        }
        printf("(%d, %d, %d)",compression_result[i][0],compression_result[i][1], compression_result[i][2]);
        if(i < index - 1){
            printf(",\n");
        }
    }
    printf("}\n");
}
/**
 * 稀疏数组压缩-三元组压缩法之解压缩
 * @param compression_result
 */
void sparse_array_decompression(int compression_result[][3]){
    //先根据二位数组第一行的三个值复原出稀疏数组的基本形状
    int row = compression_result[0][0];
    int column = compression_result[0][1];
    int sparse_array[row][column];
    //初始化所有元素为0
    for(int i = 0; i < row; i++){
        for(int k = 0; k < column; k++){
            sparse_array[i][k] = 0;
        }
    }
    //取出非0元素的个数
    int value_count = compression_result[0][2];
    //复原
    for(int i = 1; i <= value_count; i++){
        //发现存储的行值为空，说明已经没有非0元素了
        if(compression_result[i][0] == 0){
            break;
        }
        int row_val = compression_result[i][0];
        int column_val = compression_result[i][1];
        int value = compression_result[i][2];
        sparse_array[row_val-1][column_val-1] = value;
    }
    //打印解压缩结果
    printf("解压缩结果：\n");
    for(int i = 0; i < row; i++){
        for(int k = 0; k < column; k++){
            int value = sparse_array[i][k];
            printf("%d\t", value);
        }
        printf("\n");
    }

}

int main(){
    //定义稀疏数组，当然这里非0元素占有率还达不到稀疏数组的程度，要是稀疏数组，不进行压缩那将更占用空间
    int sparse_array[6][10] = {
            {0,8,0,0,4,1,0,0,0,0},
            {1,0,0,0,9,0,0,0,0,7},
            {0,0,0,0,0,0,0,0,0,0},
            {0,0,1,0,0,0,0,0,0,0},
            {0,0,0,2,0,0,0,0,0,0},
            {0,0,0,0,0,0,2,0,4,0},
    };
    //用来存储压缩结果
    int compression_result[20][3];
    //对稀疏数组进行压缩
    sparse_array_compression(sparse_array,compression_result);
    //传入压缩结果进行解压缩
    sparse_array_decompression(compression_result);
    return 0;
}