稀疏数组

稀疏数组
当一个数组中大部分元素为0或者为同一个值时，可以用稀疏数组来进行保存该数组。
稀疏数组的处理方法：
（1）记录数组一共有几行几列，有多少个不同的值
（2）把具有不同值的元素的行和列及其值记录在一个小规模的数组中，从而缩小程序的规模。

如下例子：

0	0	0	22	0	0	15
0	11	0	0	0	17	0
0	0	0	-6	0	0	0
0	0	0	0	0	39	0
91	0	0	0	0	0	0
0	0	28	0	0	0	0

假设上述表格为一二维数组，将其转化为稀疏数组
首先记录其行数和列数，以及其具有不同值的元素的个数。

	行（row）	列（col）	值（value）
[0]	6	7	8	[0][0]位置存放6，表示原数组有6行、[0][1]位置存放7，表示原数组有7行、[0][2]位置存放8，表示原数组存在8个不同的元素个数
[1]	0	3	22	[1][0]位置存放0，表示原数组的第0行、[1][1]位置存放3，表示原数组的第3列、[1][2]位置存放22，表示原数组[0][3]位置存放的元素为22
[2]	0	6	15	[2][0]位置存放0，表示原数组的第0行、[2][1]位置存放6，表示原数组的第6列、[2][2]位置存放15，表示原数组[0][6]位置存放的元素为15
[3]	1	1	11	… …
[4]	1	5	17	… …
[5]	2	3	-6	… …
[6]	3	5	39	… …
[7]	4	0	91	… …
[8]	5	2	28	… …

可以看到，原数组的大小是6行 * 7列 = 42，化为稀疏数组后的大小为 9行 * 3列 = 27

二维数组转稀疏数组的思路

1、 遍历原始的二维数组，得到有效数据的个数sum
2、 根据sum创建稀疏数组sparseArray[sum+1,3]（其中sum+1是根据原数组的有效数据的个数进行变化的，而3这个数字是固定的）
3、 将二维数组的有效数据存放到稀疏数组中

稀疏数组转原数组的思路

1、 首先读取稀疏数组的第一行，根据第一行的数据创建一个二维数组，其中[0][0]位置表示的是行数，[0][1]位置表示的是列数，[0][2]位置表示的是有效的数据数。这样就可以创建一个二维数组。
2、 读取除第一行外的其余各行数据，并赋值给二维数组即可。其中稀疏数组中[x][0]位置存放的是原数据的行数，[x][1]位置存放的是原数据的列数，[x][2]位置存放的是原数据。

就拿上面的例子进行代码的演示

public class SparseArray {
    public static void main(String[] args) {
        // 创建一个二维数组
        int[][] array = new int[][]{{0,0,0,22,0,0,15},
                                    {0,11,0,0,0,17,0},
                                    {0,0,0,-6,0,0,0},
                                    {0,0,0,0,0,39,0},
                                    {91,0,0,0,0,0,0},
                                    {0,0,28,0,0,0,0}};

        // 1.获取该数组的行数
        int row = array.length ;
        // 2.获取该数组的列数
        int col = array[0].length ;
        // 3.获取该数组中的有效数据数
        int sum = 0 ;
        System.out.println("原数组：");
        for(int i = 0 ; i < row ; i ++) {
            for(int j = 0 ; j < col ; j ++) {
                if(array[i][j] != 0) {
                    sum ++ ;
                }
                System.out.print(array[i][j] + "  ");
            }
            System.out.println();
        }

        // 创建出该稀疏数组
        int[][] sparseArray = new int[sum + 1][3] ;
        sparseArray[0][0] = row ;
        sparseArray[0][1] = col ;
        sparseArray[0][2] = sum ;

        // 循环遍历出原数组中有效的数据，将其行、列、值都存放到稀疏数组中
        int count = 1 ; // 表示第几个非0数据
        for(int i = 0 ; i < row ; i ++) {
            for(int j = 0 ; j < col ; j ++) {
                if(array[i][j] != 0) {
                    sparseArray[count][0] = i ;
                    sparseArray[count][1] = j ;
                    sparseArray[count][2] = array[i][j] ;
                    count ++ ;
                }
            }
        }

        // 遍历稀疏数组
        System.out.println("稀疏数组：");
        for(int i = 0 ; i < sparseArray.length ; i ++) {
            for(int j = 0 ; j < sparseArray[0].length ; j ++) {
                System.out.print(sparseArray[i][j] + "  ");
            }
            System.out.println();
        }

        // 将稀疏数组恢复为原二维数组
        int[][] array1 = new int[sparseArray[0][0]][sparseArray[0][1]] ;
        for(int i = 1 ; i < sparseArray.length ; i ++) {
            array1[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2] ;
        }

        // 遍历恢复后的二维数组
        System.out.println("恢复后的二维数组：");
        for(int i = 0 ; i < array1.length ; i ++) {
            for (int j = 0 ; j < array1[0].length ; j ++) {
                System.out.print(array1[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

其实在这个例子中并不能很好的体现出稀疏数组的优越性，0元素或相同元素越多，稀疏数组的好处体现的越明显，节省的空间就越多。