稀疏数组的压缩及其还原

1.稀疏矩阵的概念

在矩阵中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵；

2.稀疏矩阵的压缩

如果要把一个含有如此多0元素的稀疏矩阵存储到计算机中，这些没有意义的0同样地会消耗掉计算机的内存，那么这势必造成计算机内存的浪费。那么，对于稀疏矩阵的存储，我们应该如何去处理呢？下面介绍一个例子：

例： 现在要模拟一个11*11的五子棋棋盘的存档和续局。棋盘上有黑、白两种棋子，分别用1、2来表示，没有棋子的地方，则用0来表示。假设这个棋盘是只有3颗棋子，2颗白棋子，1颗黑棋子，则该棋盘抽象出来，就是一个稀疏矩阵，其中非0元素只有3个，分别是1，2，2。现在，不想下棋了，那么要保存这个棋盘，也就是保存这个稀疏矩阵。

3. 实现源代码

package com.luobin.DataStructure;

/**
 * @author LuoBin
 * @version 1.0
 * @date 2021/7/31 7:09 下午
 */
public class sparseArray {
    // sparseArray 叫做稀疏数组的意思

    public static void main(String[] args) {
        // 创建原始的二维数组
        // 0 表示没有棋子， 1 表示黑色 2 表示黑色
        // 创建十一行，十一列的数组
        // 创建一个棋盘
        int chessArr1[][] = new int[11][11];

        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[6][6] = 2;

        // 对于二维数组进行输出

        System.out.println("原始的二维数组如下所示：");
        for (int[] row : chessArr1){
            for (int data : row){
                // \t 相当于 tab
                System.out.printf("%d\t",data);
            }
            // 一行输出结束之后，进行换行输出
            System.out.println();
        }

        // 将二维数组转换成为稀疏数组
        // 1、对二维的数组进行遍历， 得到非 0 数据的个数

        int sum = 0;
        for (int i = 0;i < chessArr1.length;i++){
            for (int j = 0;j < chessArr1.length;j++){
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }
//        System.out.println("非 0 的个数 Sum = " + sum);

        // 2、创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        // 给稀疏数组进行赋值操作
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        // 对二维数组进行遍历，非 0 的数值存放到 sparseArr 中
        int count = 0; // 用来记录这是第几个非 0 数据
        for (int i = 0;i < chessArr1.length;i++){
            for (int j = 0;j < chessArr1.length;j++){

                if (chessArr1[i][j] !=0) {
                    count++;
                    // 建立的稀疏数组，数组中的每一个元素，存放相关的数据的行数，列数以及对应的数值
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        // 将稀疏数组进行输出
        System.out.println();
        System.out.println("得到的稀疏数组为：");
        for (int i = 0;i < sparseArr.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }

        // 将稀疏矩阵进行原来矩阵的恢复
        /*
            第一步：先读取稀疏数组的第一行，进行数组大小的获取
            第二步：将稀疏矩阵的最后几行数据，进行赋值给原始的二维数组
         */
        // 将数组的大小进行获取
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        System.out.println("======");

        for (int i = 1;i < sparseArr.length;i++){
            // chessArr2[][]  中的行以及列从 稀疏数组中进行获取 sparseArr[i][0]（获取到行）
            // 值从稀疏数组中的第三列进行获取
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        System.out.println("下面是恢复后的二维数组：");


        for (int[] row : chessArr2){
            for (int data : row){
                // \t 相当于 tab
                System.out.printf("%d\t",data);
            }
            // 一行输出结束之后，进行换行输出
            System.out.println();
        }
    }
}