稀疏数组和二位数组的转换

稀疏数组的应用场景

当一个二位数组中出现了大量的数据为0或者出现了大量的重复元素时，导致大部分空间的浪费，此时可以使用稀疏数组来进行表示，从而可以避免空间的浪费。

原始的二位数组

使用稀疏数组进行表示

1. 第一行表示：上述二位数组的行、列、非零值
2. 第二行表示：第一个非零值对应的行、列、值
3. 第三行表示：第二个非零值对应的行、列、值
   原本5×5的数组改成了3×3的数组，从而节省了很大空间

二位数组转稀疏数组的思路

1.遍历原始的二位数组，得到有效数据的个数sum
2.根据sum就可以创建稀疏数组sparseArray int[sum+1][3]
3.将二位数组的有效数据存入到稀疏数组中

将稀疏数组转原始的二位数组的思路

1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二位数组
2. 在读取稀疏数组后几行的数据并赋给原始的二位数组即可。

public static void main(String[] args) {
        /**
         *  创建一个原始的二位数组 11*11
         *  0:表示没有棋子，1表示黑子  2表示蓝子
         */
        int[][] chessArray = new int[11][11];
        chessArray[1][2] = 1;
        chessArray[2][3] = 2;
        //输出原始的二位数组
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray[i].length; j++) {
                System.out.print(chessArray[i][j] + " ");
            }
            System.out.println();
        }
        /**
         * 先遍历二位数组，得到非零数据的个数
         */
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray[i].length; j++) {
                if (chessArray[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("原始二位数组中的非零值:" + sum);
        /**
         * 创建对应的稀疏数组
         */
        int[][] sparseArray = new int[sum + 1][3];
        /**
         * 稀疏数组中第一行第一列表示原始的二维数组中的行数
         * 列数
         * 非零元素的个数
         */
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = 2;
        /**
         * 遍历二位数组
         * 将非零的值存放到稀疏数组中
         */
        int count = 1;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray[i].length; j++) {
                if (chessArray[i][j] != 0) {
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArray[i][j];
                    count++;
                }
            }
        }

        /**
         * 输出稀疏数组
         */
        System.out.println();
        System.out.println("得到的稀疏数组为:");
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                System.out.print(sparseArray[i][j] + "\t");
            }
            System.out.println();
        }

    }

将稀疏数组转换为原始的二位数组

/**
         * 将稀疏数组还原为原始的二位数组
         * 首先获取原始二位数组的行和列
         */
        int row = 1;

        int[][] arr = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            arr[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //恢复后的二位数组
        System.out.println();
        System.out.println("恢复后的二位数组:");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }