稀疏数组（实现稀疏数组的生成和还原）

稀疏数组

如上图右，稀疏数组第一行表示的是在6行7列的数组中有8个值不为0的元素

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

具体实现如下：

import java.util.Arrays;

public class SparseArray {
    public static void main(String[] args) {
        int[][] num=new int[6][7];
        num[2][3]=1;
        num[4][5]=2;
        num[0][3]=3;
        System.out.println("原数组为：");
        //打印原数组
        for (int[] a : num) {
            System.out.println(Arrays.toString(a));
        }
        System.out.println("稀疏数组为：");
        //打印稀疏数组
        int[][] sparse_array=PrintSparse(num);
        for (int[] a : sparse_array) {
            System.out.println(Arrays.toString(a));
        }

        //=========================================================================================================================
        //通过稀疏数组，还原成原数组
        int[][] original=new int[sparse_array[0][0]][sparse_array[0][1]];  //稀疏数组的第0行第0列为原数组的行的个数
        for (int i = 1; i < sparse_array.length; i++) {    //i从1开始，因为稀疏数组第0行，存的不是有效值
            original[sparse_array[i][0]][sparse_array[i][1]]=sparse_array[i][2];      //稀疏数组从第1行开始，第一列存的是有效值的行，第二列存的是有效值的所在列，第三列存的是有效值
        }
        System.out.println("还原稀疏数组：");
        for (int[] a : original) {
            System.out.println(Arrays.toString(a));

        }
    }

    
    //打印稀疏数组的方法
    public static int[][] PrintSparse(int[][] num){
        //判断有效值的个数
        int sum=0;
        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num[i].length; j++) {
                if (num[i][j]!=0) {                //如果该二维数组的元素值不为0，则有效值sum加1
                    sum++;
                }
            }
        }
        //打印稀疏数组
        int[][] Sparse_array=new int[sum+1][3];    //稀疏数组的行数等于有效值数加1，列数恒为3
        Sparse_array[0][0]= num.length;            //稀疏数组的第一行的第1个元素为原数组的行数
        Sparse_array[0][1]=num[0].length;          //稀疏数组的第一行的第2个元素为原数组的列数
        Sparse_array[0][2]=sum;                    //稀疏数组的第一行的第3个元素为原数组的有效值的个数
        //遍历原数组将不为0的元素赋值给稀疏数组
        int count=0;   //通过count将稀疏数组行指针后移
        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num[i].length; j++) {
                if (num[i][j]!=0) {
                    count++;    //行下移
                    Sparse_array[count][0]=i;              //原数组的有效元素在第几行，赋值给稀疏数组第1列元素
                    Sparse_array[count][1]=j;              //原数组的有效元素在第几列
                    Sparse_array[count][2]=num[i][j];      //原数组的有效元素的值，赋值给稀疏数组的第3列元素
                }
            }
        }
        return Sparse_array;
    }
}