稀疏数组与二维数组相互转换

稀疏数组

稀疏数组其实本质还是个二维数组，只不过它有以下特性：
1）普通存储方式列固定为三列，第一行存储原始数据总行数，总列数，总的非0数据个数，接下来每一行都存储非0数所在行，所在列，和具体值
2）数据紧凑，节省存储空间

java代码实现稀疏数组与二维数组相互转换

public class SparseArray {
    public static void main(String[] args) {
        // 初始化一个5行6列的二维数组
        int row = 5;
        int col = 6;
        int[][] arr = new int[row][col];
        arr[0][1] = 1;
        arr[1][2] = 2;
        arr[2][3] = 3;
        System.out.println("二维数组：");
        // 打印初始化完成的二维数组
        printArr(arr, row, col);
        // 二维数组 => 稀疏数组，并打印稀疏数组元素
        System.out.println("二维数组 => 稀疏数组：");
        int[][] sparseArray = toSparseArray(arr, col);
        printArr(sparseArray, sparseArray.length, 3);
        // 稀疏数组 => 二维数组，并打印转换后的原始二维数组元素
        System.out.println("稀疏数组 => 二维数组：");
        int[][] originalArr = toTwoDimensionalArray(sparseArray);
        printArr(originalArr, originalArr.length, col);
    }

    /**
     * 打印二维数组元素
     *
     * @param arr 二维数组
     * @param row 二维数组行数
     * @param col 二维数组列数
     */
    private static void printArr(int[][] arr, int row, int col) {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }

    /**
     * 二维数组转稀疏数组
     *
     * @param arr 二维数组
     * @param col 二维数组的列
     * @return 稀疏数组
     */
    private static int[][] toSparseArray(int[][] arr, int col) {
        // 二维数组有效个数
        int num = getValidNum(arr, col);
        // num+1为稀疏数组的行数，其中1表示第一行，其余行数与num相同
        int[][] sparseArr = new int[num + 1][3];
        sparseArr[0][0] = arr.length;
        sparseArr[0][1] = col;
        sparseArr[0][2] = num;
        // count 表示第count个有效数据，作为稀疏数组的行数
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < col; j++) {
                if (arr[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr[i][j];
                }
            }
        }
        return sparseArr;
    }

    /**
     * 获取二维数组中非0数据个数
     *
     * @param arr 二维数组
     * @param col 二维数组列数
     * @return 有效数据个数
     */
    private static int getValidNum(int[][] arr, int col) {
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < col; j++) {
                if (arr[i][j] != 0) {
                    num++;
                }
            }
        }
        return num;
    }

    /**
     * 稀疏数组转二维数组
     *
     * @param arr 稀疏数组
     * @return 二维数组
     */
    private static int[][] toTwoDimensionalArray(int[][] arr) {
        int originalRow = arr[0][0];
        int originalCol = arr[0][1];
        int[][] originalArr = new int[originalRow][originalCol];
        for (int i = 1; i < arr.length; i++) {
            // 从第二行开始，将稀疏数组的row,col,val赋值给对应原始数组original[row][col] = val
            originalArr[arr[i][0]][arr[i][1]] = arr[i][2];
        }
        return originalArr;
    }
}