稀疏数组的使用和还原

稀疏数组

稀疏数组是对一个二维数组进行压缩，形成一个新的数组，这个新的数组就叫稀疏数组，它能节约我们的存储空间。
例如一个二维数组，其中有4个有效值

经过转换变成稀疏数组为：

稀疏数组的第一行第一列10表示原数组的行数
稀疏数组的第一行第二列10表示原数组的列数
稀疏数组的第一行第三列4表示原数组有效值个数
稀疏数组的第二行三个值2 2 1表示原数组第一个有效值的位置为array[2][2],值为1
稀疏数组的第二行三个值5 5 2表示原数组第二个有效值的位置为array[5][5],值为2
…
由此可见一个复杂的数组经过压缩，变成了一个简单的稀疏数组，我们只需存储稀疏数组就可以了，极大节约了存储空间。

相关代码

下面一段代码是变成稀疏数组的方法，我们传入一个二维数组，返回值就是稀疏数组。

public static int[][] change(int[][] array){
        //获取数组中有效值个数
        int count=0;
        for (int[] ints : array) {
            for (int anInt : ints) {
                if(anInt!=0){
                    count++;
                }
            }
        }
        //创建稀疏数组，并给第一行赋值
        int[][] arr=new int[count+1][3];
        arr[0][0]=array.length;
        arr[0][1]=array[0].length;
        arr[0][2]=count;
        //给稀疏数组后面的行赋值
        int num=1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                if(array[i][j]!=0){
                    arr[num][0]=i;
                    arr[num][1]=j;
                    arr[num][2]=array[i][j];
                    num++;
                }
            }
        }
        return arr;
    }

下面一段代码是还原的方法，我们传入一个稀疏数组，就会返回原数组。

public static int[][] revivification(int[][] arr){
       //获取原数组的行列并创建原数组
        int row= arr[0][0];
       int column=arr[0][1];
       int[][] array=new int[row][column];
       //给原数组赋值
        int value=0;
        for (int i = 1; i < arr.length; i++) {
            //取出每一行的三个值，对原数组进行赋值
            for (int j = 0; j < arr[i].length; j++) {
                if(j==0){
                    row=arr[i][j];
                }
                if(j==1){
                    column=arr[i][j];
                }
                if(j==2){
                    value=arr[i][j];
                }
            }
            array[row][column]=value;
        }
        return array;
    }