01-数组

稀疏矩阵

稀疏矩阵：数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律

二维数组转稀疏数组：

1. 获取原始数组的有效数据数量
2. 根据有效数据数量创建稀疏数组
3. 设置稀疏数组第0行：原始矩阵行数，原始矩阵列数，有效数据量
4. 将原始数组的有效数据存入稀疏数组：有效数据所在行，有效数据所在列，有效数据值

稀疏数组转二维数组：

1. 根据稀疏数组第0行数据，创建二维数组
2. 读取稀疏数组其他几行数据，并赋值给二维数组

代码实现：

import java.util.Arrays;

public class SparseMatrix {
    private static int getValidSize(int[][] source) {
        // 有效数据量
        int valid = 0;
        for (int r = 0; r < source.length; r++) {
            for (int c = 0; c < source[r].length; c++) {
                if (source[r][c] != 0) {
                    valid++;
                }
            }
        }
        return valid;
    }

    // 二维数组转稀疏数组
    public static int[][] parseSourceToSparse(int[][] source) {
        // 获取原始数组的有效数据数量
        int validSize = getValidSize(source);
        // 根据有效数据数量创建稀疏数组
        int[][] sparse = new int[validSize + 1][3];
        // 设置稀疏数组第0行：原始矩阵行数，原始矩阵列数，有效数据量
        sparse[0][0] = source.length;
        sparse[0][1] = source[0].length;
        sparse[0][2] = validSize;
        // 记录是第几个非0数据
        int count = 0;
        // 将原始数组的有效数据存入稀疏数组：有效数据所在行，有效数据所在列，有效数据值
        for (int r = 0; r < source.length; r++) {
            for (int c = 0; c < source[r].length; c++) {
                if (source[r][c] != 0) {
                    count++;
                    sparse[count][0] = r;
                    sparse[count][1] = c;
                    sparse[count][2] = source[r][c];
                }
            }
        }
        return sparse;
    }

    // 稀疏数组转二维数组
    public static int[][] parseSparseToSource(int[][] sparse) {
        // 根据稀疏数组第0行数据，创建二维数组
        int[][] source = new int[sparse[0][0]][sparse[0][1]];
        // 读取稀疏数组其他几行数据，并赋值给二维数组
        for (int r = 1; r < sparse.length; r++) {
            source[sparse[r][0]][sparse[r][1]] = sparse[r][2];
        }
        return source;
    }

    public static void main(String[] args) {
        int[][] source = new int[9][9];
        source[0][0] = 1;
        source[8][8] = 1;
        int[][] sparse = parseSourceToSparse(source);
        for (int r = 0; r < sparse.length; r++) {
            System.out.println(Arrays.toString(sparse[r]));
        }
        int[][] recover = parseSparseToSource(sparse);
        for (int r = 0; r < recover.length; r++) {
            System.out.println(Arrays.toString(recover[r]));
        }
    }
}