什么是稀疏数组？

---

稀疏数组

稀疏数组一般使用在一个二维数组存储着大量无效数据的场景中。举个例子：一个二维数组存储了100个数据，有效数据只有2个，这种情况就可以考虑使用稀疏数组来存储。

---

一、定义

稀疏数组可以看作是二维数组的压缩存储。其存储形式为：

• 第一行记录二维数组的行数，列数，以及有效数据的个数
• 其他行记录每个有效数据所在的行数，列数，以及值

二、代码实现

1.二维数组转稀疏数组

思路：
 1. 获取二维数组的信息 row col
 2. 遍历二维数组，获取有效数据的个数 num，以及每个有效数据的信息 ValidData
 3. 根据 num 创建稀疏数组 new int[num + 1][3]
 4. 将二维数组的信息存入到稀疏数组第一行中
 5. 从第二行开始，将每个有效数据的信息存入到稀疏数组中

ValidData类：

    /**
     * 有效数据
     * 静态内部类
     */
    static class ValidData {

        /**
         * 所在的行数
         */
        private int atRow;

        /**
         * 所在的列数
         */
        private int atCol;

        /**
         * 值
         */
        private int value;

        public ValidData(int atRow, int atCol, int value) {
            this.atRow = atRow;
            this.atCol = atCol;
            this.value = value;
        }

        public int getAtRow() {
            return atRow;
        }

        public int getAtCol() {
            return atCol;
        }

        public int getValue() {
            return value;
        }

        public void setAtRow(int atRow) {
            this.atRow = atRow;
        }

        public void setAtCol(int atCol) {
            this.atCol = atCol;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }

getSparseArray()方法：

    /**
     * 通过二维数组获取对应的稀疏数组
     * @param twoArray 二维数组
     */
    public static int[][] getSparseArray(int[][] twoArray) {
        // 1. 获取二维数组的信息 row col
        int row = twoArray.length;
        int col = twoArray[0].length;
        // 2. 遍历二维数组，获取有效数据的个数 num，以及每个有效数据的信息 ValidData
        int num = 0;
        List<ValidData> list = new ArrayList<>();
        for (int i = 0; i < twoArray.length; i++) {
            for (int j = 0; j < twoArray[i].length; j++) {
                int data = twoArray[i][j];
                if (isValidData(data)) {
                    num++;
                    list.add(new ValidData(i + 1, j + 1, data));
                }
            }
        }
        // 3. 根据 num 创建稀疏数组 new int[num + 1][3]
        int[][] sparseArray = new int[num + 1][3];
        // 4. 将二维数组的信息存入到稀疏数组第一行中
        sparseArray[0][0] = row;
        sparseArray[0][1] = col;
        sparseArray[0][2] = num;
        // 5. 从第二行开始，将每个有效数据的信息存入到稀疏数组中
        int index = 1;
        for (ValidData validData : list) {
            sparseArray[index][0] = validData.getAtRow();
            sparseArray[index][1] = validData.getAtCol();
            sparseArray[index][2] = validData.getValue();
            index++;
        }
        return sparseArray;
    }

2.稀疏数组转二维数组

思路
 1. 遍历稀疏数组，读取第一行的数据 row、col，根据 row 和 col 创建二维数组 new int[row][col]
 2. 读取其它行的数据将每个有效数据存入二维数组对应的位置

---

3.完整代码

SparseArray类：

/**
 * 稀疏数组
 */
public class SparseArray {

    /**
     * 无效数据
     */
    public static final int invalidData = 0;

    /**
     * 有效数据
     */
    static class ValidData {

        /**
         * 所在的行数
         */
        private int atRow;

        /**
         * 所在的列数
         */
        private int atCol;

        /**
         * 值
         */
        private int value;

        public ValidData(int atRow, int atCol, int value) {
            this.atRow = atRow;
            this.atCol = atCol;
            this.value = value;
        }

        public int getAtRow() {
            return atRow;
        }

        public int getAtCol() {
            return atCol;
        }

        public int getValue() {
            return value;
        }

        public void setAtRow(int atRow) {
            this.atRow = atRow;
        }

        public void setAtCol(int atCol) {
            this.atCol = atCol;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }

    /**
     * 通过二维数组获取对应的稀疏数组
     * @param twoArray 二维数组
     */
    public static int[][] getSparseArray(int[][] twoArray) {
        // 1. 获取二维数组的信息 row col
        int row = twoArray.length;
        int col = twoArray[0].length;
        // 2. 遍历二维数组，获取有效数据的个数 num，以及每个有效数据的信息 ValidData
        int num = 0;
        List<ValidData> list = new ArrayList<>();
        for (int i = 0; i < twoArray.length; i++) {
            for (int j = 0; j < twoArray[i].length; j++) {
                int data = twoArray[i][j];
                if (isValidData(data)) {
                    num++;
                    list.add(new ValidData(i + 1, j + 1, data));
                }
            }
        }
        // 3. 根据 num 创建稀疏数组 new int[num + 1][3]
        int[][] sparseArray = new int[num + 1][3];
        // 4. 将二维数组的信息存入到稀疏数组第一行中
        sparseArray[0][0] = row;
        sparseArray[0][1] = col;
        sparseArray[0][2] = num;
        // 5. 从第二行开始，将每个有效数据的信息存入到稀疏数组中
        int index = 1;
        for (ValidData validData : list) {
            sparseArray[index][0] = validData.getAtRow();
            sparseArray[index][1] = validData.getAtCol();
            sparseArray[index][2] = validData.getValue();
            index++;
        }
        return sparseArray;
    }

    /**
     * 判断数据是否是有效数据
     * @param data 数据
     * @return true 或者 false
     */
    public static boolean isValidData(int data) {
        return !(data == invalidData);
    }


    /**
     * 打印二维数组
     * @param twoArray 二维数组
     */
    public static void print(int[][] twoArray) {
        for (int[] array : twoArray) {
            for (int data : array) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
    }


    /**
     * 主方法
     * @param args 参数列表
     */
    public static void main(String... args) {
        // 二维数组
        int[][] twoArray = new int[11][8];
        twoArray[2][3] = 1;
        twoArray[3][4] = 2;
        System.out.println("原数组为:");
        print(twoArray);
        int[][] sparseArray = getSparseArray(twoArray);
        System.out.println("稀疏数组为:");
        print(sparseArray);
    }

}

总结

以上就是今天要讲的内容，本文简单介绍了稀疏数组的定义以及二维数组和稀疏数组的转换。