稀疏数组 | Hobo's blog

为什么要使用稀疏数组

当我们存储有大量重复元素的二维数组时，如果使用一般的二维数组就造成有大量重复元素，很浪费空间，
例如这个棋盘，如果要记录棋子的位置我们会想到使用二维数组（1代表黑，2代表蓝），当使用普通二维数组时，那些大量重复的0，占用了很大的内存空间。
于是我们就可以使用稀疏数组来存储有效数据

稀疏数组怎么用

稀疏数组一共有三列（列固定），分别表示行号、列、值

第一行：记录初始数组的行、列、有效值个数
其他行：依次记录有效值的行号、列号、值
稀疏数组总行数为有效值（假设有效值为num）num+1，列数为3

思路与实现

数组转稀疏思路

先定义好一个二维数组数组，并赋值
遍历数组，获取有效值个数num
定义稀疏数组，行数为num+1，列数为3，为数组第一行赋值
再次遍历初始数组，获取有效值，赋值给稀疏数组
定义完成

稀疏数组转二维数组

先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
再读取稀疏数组后几行的数据，并赋值给原始的二维数组即可

代码

public static void main(String[] args) {
        //创建一个原始的二维数组 11 * 11
        //0：表示没有棋子，1 黑子  2 蓝字
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[5][4] = 1;
        for (int[] row : chessArr1) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
        //得到稀疏数组
        int[][] sparseArr = toSparseArray(chessArr1);
        //输出稀疏数组的形式
        System.out.println("-----------");
        System.out.println("得到的稀疏数组");
        for (int[] ints : sparseArr) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t ");
            }
            System.out.println();
        }

        System.out.println("-------------");
        System.out.println("恢复后的二维数组");
        //将稀疏数组 恢复成 原始的二维数组
        int[][] chessArr2 = recover(sparseArr);
        for (int[] ints : chessArr2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
        /**
     * 将二维数组 转 稀疏数组的思路
     * 1、先遍历二维数组 得到非0数据的个数
     * @param chessArray
     * @return
     */
    public static int[][] toSparseArray(int[][] chessArray){
        //有效数的个数
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length;j++) {
                if (chessArray[i][j]!=0) {
                    sum++;
                }
            }
        }
        //2、创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = chessArray.length;
        sparseArr[0][1] = chessArray.length;
        sparseArr[0][2] = sum;
        //用于记录是第几个非0数
        int count = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length;j++) {
                if (chessArray[i][j]!=0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] =j;
                    sparseArr[count][2] = chessArray[i][j];
                }
            }
        }
        return sparseArr;
    }

    /**
     * 1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
     * 2、再读取稀疏数组后几行的数据，并赋值给 原始的二维数组 即可
     *
     * @param sparseArr
     * @return
     */
    public static int[][] recover(int[][] sparseArr){
        int row = sparseArr[0][0];
        int col = sparseArr[0][1];
        int validNum = sparseArr[0][2];

        int chessArr2[][] = new int[row][col];
        for (int i = 1;i<sparseArr.length;i++) {
            int chessRow = sparseArr[i][0];
            int chessCol =  sparseArr[i][1];
            int chessVal = sparseArr[i][2];
            chessArr2[chessRow][chessCol] = chessVal;
        }
        return chessArr2;
    }