Java 稀疏数组

实际需求（应用场景）

稀疏数组基本介绍

上面表格的第一行中的6、7、8 表示左边的二维数组一共有 6 行 7 列，在数组中有 8 个不同的值，分别是22、15、 11、17、 -6、 39、 91、 28.

表格的其他行表示每个值所在的行列信息，如第二行表示 22 这个值在二维数组的第 0 行第 3 列

稀疏数组转换的思路分析

以上面的实际需求中的数组为例进行分析

二维数组 ------> 稀疏数组

1. 遍历原始的二维数组，得到有效数据的个数 sum
2. 根据 sum 创建稀疏数组 sparseArr （类型为：int[sum + 1][3]）
3. 在稀疏数组的第一行存入二维数组的行列总数和有效数据个数 sum
4. 从稀疏数组的第二行开始，将二维数组的有效数据及其行列信息存入稀疏数组中

稀疏数组 ------> 二维数组

1. 先读取稀疏数组的第一行数据，根据第一行的数据创建原始二维数组， 如 chessArr2 = int[11][11]
2. 在读取稀疏数组后几行的数据，将读取到的有效数据赋值给原始的二维数组即可

稀疏数组的代码实现

根据上述思路分析，代码实现如下：

class SparseArray {
    public static void main(String[] args) {
        // 创建一个原始的二维数组 11 * 11 大小
        int[][] chessArr1 = new int[11][11];
        // 0 表示没有棋子， 1 表示黑子， 2 表示蓝子
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        // 输出原始的二维数组
        System.out.println("原始的二维数组：");
        for (int[] row : chessArr1) {
            for (int data : row) {
                System.out.printf(data + "\t");
            }
            System.out.println();
        }

        // 二维数组 ------> 稀疏数组
        // 1、遍历原始的二维数组，得到有效数据的个数 sum
        int sum = 0;
        for (int[] row : chessArr1) {
            for (int data : row) {
                if (data != 0) {
                    sum++;
                }
            }
        }
        System.out.println("sum 的值为：" + sum);

        // 2、根据 sum 创建稀疏数组 sparseArr （类型为：int[sum + 1][3]）
        int[][] sparseArr = new int[sum + 1][3];

        // 3、在稀疏数组的第一行存入二维数组的行列总数和有效数据个数 sum
        sparseArr[0][0] = 11; // 存储原始二维数组 chessArr1 的行数
        sparseArr[0][1] = 11; // 存储原始二维数组 chessArr1 的列数
        sparseArr[0][2] = sum; // 存储原始二维数组 chessArr1 的有效数据个数

        // 4、从稀疏数组的第二行开始，遍历二维数组，将数组中的有效数据及其行列信息存入稀疏数组中
        int row = 1;
        // 遍历原始二维数组
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    sparseArr[row][0] = i;
                    sparseArr[row][1] = j;
                    sparseArr[row][2] = chessArr1[i][j];
                    row++;
                }
            }
        }
        // 输出得到的稀疏数组
        System.out.println("得到的稀疏数组如下：");
        for (int[] i : sparseArr) {
            for (int j : i) {
                System.out.printf(j + "\t");
            }
            System.out.println();
        }

        // 稀疏数组 ------> 二维数组
        // 先读取稀疏数组的第一行数据，根据第一行的数据创建原始二维数组，如 chessArr2 = int[11][11]
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

        // 在读取稀疏数组后几行的数据，将读取到的有效数据赋值给原始的二维数组即可
        for (int i = 1; i < sparseArr.length; i++) {
            int row1 = sparseArr[i][0];
            int col1 = sparseArr[i][1];
            int val = sparseArr[i][2];
            chessArr2[row1][col1] = val;
        }
        System.out.println("还原后的二维数组：");
        for (int[] i : chessArr2) {
            for (int data : i) {
                System.out.printf(data + "\t");
            }
            System.out.println();
        }
    }
}