其实稀疏数组更多的是一种思想，而不是一种全新独立的数据结构。它本质上也就是一个二维数组。

稀疏数组简介以及应用场景

当一个数组容量很大，但是其中有效数据很少且是稀疏分布时，我们就可以使用稀疏数组来减少不必要的内存消耗。
注：这里的有效数据，也可以理解为与绝大部分数据不同的。加上这个理解后，稀疏数组的应用场景会多很多。

其实思想很简单，构建出来一个二维数组，然后把有效数据的坐标都一一标记出来放进二维数组中。

稀疏数组的结构

稀疏数组本质上也是一个数组。
稀疏数组由（N+1）x3构成。
第一行的三个值依次表示

原数组的行号	原数组的列号	有几个格子有数据

之后的每一行都表示一个特定的值。

有意义值的行号	有意义值的列号	有意义的值

所以我们可以得到假设一个数组有效值数量为N，则他的行数为N+1。
通过稀疏数组的结构，我们又能得到一个信息。稀疏数组比较适合用来处理规整数组（即矩阵），如果不是矩阵但同时又满足稀疏数组应用场景的，可以通过数组补齐的方式，把原数组变成矩阵。

稀疏数组实现

public class SparseArray {

    /**
     * 把普通二维规整数组变成稀疏数组
     *
     * @param array        二维规整数组
     * @param defaultValue 二维数组中默认的值（大部分坐标的值）
     * @return 稀疏数组
     */
    public static int[][] toSparseArray(int[][] array, int defaultValue) {
        if (array.length == 0) {
            return new int[0][0];
        }

        //首次遍历数组 创建稀疏数组
        int sum = 0;
        int line = array.length;
        int column = array[0].length;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                if (array[i][j] != defaultValue) {
                    sum++;
                }
            }
        }

        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = line;
        sparseArray[0][1] = column;

        //第二次遍历数组 给稀疏数组塞值
        int lineNo = 1;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                if (array[i][j] != defaultValue) {
                    sum++;
                    sparseArray[lineNo][0] = i;
                    sparseArray[lineNo][1] = j;
                    sparseArray[lineNo][2] = array[i][j];
                    lineNo++;
                }
            }
        }
        sparseArray[0][2] = sum;
        return sparseArray;
    }

    /**
     * 把稀疏数组变成二维规整数组
     *
     * @param sparseArray  稀疏数组
     * @param defaultValue 二维数组中默认的值（大部分坐标的值）
     * @return 二维规整数组
     */
    public static int[][] toArray(int[][] sparseArray, int defaultValue) {
        int line = sparseArray[0][0];
        int column = sparseArray[0][1];
        int[][] array = new int[line][column];
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                array[i][j] = defaultValue;
            }
        }

        int size = sparseArray.length;
        for (int i = 1; i < size; i++) {
            array[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return array;
    }

    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[4][5] = 2;
        System.out.println("原始的二维数组~~");
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(array[i][j]+"  ");
            }
            System.out.println();
        }
        int[][] sparseArray = SparseArray.toSparseArray(array, 0);

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