稀疏数组

介绍：
当一个数组的大部分的值都想相同时，就可以使用稀疏数组对原始数组进行压缩，变为稀疏数组进行保存。
实现方法：
1，记录原始数组的行数，列数，以及由几个有效数据也就是与默认数据不同的数据。
2，建立另一个数组记录这些信息，这个数组的列数是固定的，为3，行数为有效数据+1
图解：

这样就把原来庞大的二维数组转为了一个列数为有效数据+1，行数为3的二维数组，相当于对原始的二维数组进行了一个压缩

java代码演示，我会演示从原始数如何转为稀疏数组，然后稀疏数组复原为原始数组

import com.sun.source.doctree.SummaryTree;

import java.util.zip.Inflater;
public class compress {
    public static void main(String[] args) {
        //定义一个原始数组
        int[][] original = new int[5][5];
        int count = 0;//记录原始数组的有效值
        //赋值
        original[1][1] = 1;
        original[2][3] = 2;
        original[3][3] = 3;
        //遍历原始数组
        System.out.println("原始数组********************");
        for (int[] item : original) {
            for (int i : item) {
                System.out.print(i + "\t");
                if (i != 0)//在遍历的时候顺便记录一下稀疏数组的有效值
                    count++;
            }
            System.out.println();
        }
        //创建对应的稀疏数组,数组的行是3,列都是定义为count+1,
        int[][] sparse = new int[count + 1][3];
        //稀疏数组的第一行记录的是原始数组的行，列，已经有多少个有效数据
        sparse[0][0] = original.length;
        sparse[0][1] = original[0].length;
        sparse[0][2] = count;
        //然后获取原始数组的有效数据的行，列，以及值为多少，使用循环遍历
        count = 1;//现在将count作为一个计算器使用
        for (int i = 0; i < original.length; i++) {
            for (int j = 0; j < original[i].length; j++) {
                if (original[i][j] != 0) {
                    //将有效数据记录进稀疏数组
                    sparse[count][0] = i;
                    sparse[count][1] = j;
                    sparse[count++][2] = original[i][j];
                }
            }
        }
        //遍历稀疏数组
        System.out.println("稀疏数组********************");
        for (int[] item : sparse) {
            for (int i : item) {
                System.out.print(i + "\t");
                if (i != 0)//在遍历的时候顺便记录一下稀疏数组的有效值
                    count++;
            }
            System.out.println();
        }
        //对稀疏数组进行复原,复原之后的二维数组的行，列存储在稀疏数组的第一行的前两位数据
        int[][] renew = new int[sparse[0][0]][sparse[0][1]];
        //遍历稀疏数组,直接从1开始遍历,直接遍历稀疏数组行的行数就可以了
        for (int i = 1; i < sparse.length; i++) {
            int row  = sparse[i][0];
            int line = sparse[i][1];
            int val = sparse[i][2];
            renew[row][line] = val;
        }
        //输出复原之后的数组
        //遍历稀疏数组
        System.out.println("复原的数组********************");
        for (int[] item : renew) {
            for (int i : item) {
                System.out.print(i + "\t");
                if (i != 0)//在遍历的时候顺便记录一下稀疏数组的有效值
                    count++;
            }
            System.out.println();
        }
    }
}

运行结果

原始数组********************
0	0	0	0	0	
0	1	0	0	0	
0	0	0	2	0	
0	0	0	3	0	
0	0	0	0	0	
稀疏数组********************
5	5	3	
1	1	1	
2	3	2	
3	3	3	
复原的数组********************
0	0	0	0	0	
0	1	0	0	0	
0	0	0	2	0	
0	0	0	3	0	
0	0	0	0	0