稀疏数组

1. 定义
   稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组
2. 存储

刚说到稀疏数组是一种压缩后的数组，为什么要进行压缩存储呢？
原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据却少之又少
压缩存储可以节省存储空间以避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率

3. 代码实现

package cn.chmcyz.sparsearray;

/**
 * @author 谌涣谋
 * @date 2020/5/11 - 19:44
 */
public class TestSparseArray {
    /**
     * 原始数组
     * [
     *  [0,0,0,0,0,0,0,0,0,1],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,8,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     *  [0,0,0,0,0,0,0,0,0,0],
     * ]，
     *
     * 稀疏数组
     *      row,col,val
     * [
     *     [10,10,2],
     *     [0,9,1],
     *     [3,4,8]
     * ]
     * 第一行的元素为二维数组的总行数，总列数，以及有效数据的个数
     * 第二行开始为有效数据所在的行号，列号，数据的值
     *
     * 二维数组转稀疏数组的思路：
     * 1.遍历二维数组，找有效数据的个数sum
     * 2.根据有效个数构建稀疏数组sparseArr[sum+1][3]
     * 3.将二维数组的有效数据存入稀疏数组
     *
     * 稀疏数组转化为原始数组的思路:
     * 1.根据稀疏数据的第一行的列数和行数，构建原始数组
     * 2.再读取之后的行的数据赋值给原始数据即可
     * @param args Main函数的参数
     */
    public static void main(String[] args) {
        /* 构建一个初始数组 */
        Integer[][] array = new Integer[10][10];
        array[0][9]=1;
        array[3][4]=8;
        Object[][] objects = srcToSparseArray(array, null);
        printArray(objects);
        Object[][] srcArrays=sparseToSrcArray(objects);
        printArray(srcArrays);
    }

    //初始数组转稀疏数组
    public static Object[][] srcToSparseArray(Object [][]array,Object infectiveVal) {
        /**
         * 二维数组转稀疏数组的思路：
         *  1.遍历二维数组，找有效数据的个数sum
         *  2.根据有效个数构建稀疏数组sparseArr[sum+1][3]
         *  3.将二维数组的有效数据存入稀疏数组
         */
        int sum = 0;//计算原始数组有效数据的个数
        int count=1;//定位稀疏数组当前的行号

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != infectiveVal) {
                    sum += 1;
                }
            }
        }
        Object[][] sparseArr = new Object[sum + 1][3];
        sparseArr[0][0]=array.length;
        sparseArr[0][1]=array[0].length;
        sparseArr[0][2]=sum;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != infectiveVal) {
                   sparseArr[count][0]=i;
                   sparseArr[count][1]=j;
                   sparseArr[count][2]=array[i][j];
                   count+=1;
                }
            }
        }
        return  sparseArr;
    }

    /**
     * 定义稀疏矩阵转化为原始矩阵的方法
     */
    public  static Object[][] sparseToSrcArray(Object[][] sparseArray){
        Object [][]array=new Object[(Integer)sparseArray[0][0]][(Integer)sparseArray[0][1]];
        for (int i = 1; i <sparseArray.length ; i++) {
            array[(int)sparseArray[i][0]][(int)sparseArray[i][1]]=sparseArray[i][2];
        }
        return array;
    }

    /**
     * 遍历数组的方法
     * @param array 要遍历的数组
     */
    public static void printArray(Object [][] array){
        for (Object[] objects : array) {
            for (Object object : objects) {
                System.out.print(object + ",");
            }
            System.out.println();
        }
    }
}