数据结构-1-稀疏数组

一、稀疏数组

1、概念

在使用二维数组保存数据时，如果保存的非默认值（比如 int 类型的默认值是0）的个数少于整个二维数组的大小时，就可以考虑使用稀疏数组来减少内存使用空间

稀疏数组的第一维是普通数组的 一维长度 二维长度 和 非默认元素个数；其他维是非默认元素的 一维下标 二维下标 和 元素值

2、转换步骤

1）普通数组转稀疏数组

1. 获取普通数组的一维和二维的长度，以及非默认元素的个数
2. 新建稀疏数组（一维长度是1 + 非默认元素个数，二维长度是3）
3. 遍历普通数组，给稀疏数组赋值

2）稀疏数组转普通数组

1. 获取稀疏数组的第一维，即可得到普通数组的 一维长度 二维长度 非默认元素的个数
2. 新建普通数组，并初始化默认值
3. 遍历稀疏数组，赋值非默认元素

3）示例

class SpareArray {

    /**
     * 将普通的二维数组转换为稀疏数组
     */
    public static int[][] transform(int[][] array, int defaultValue) {
        if (null == array) {
            return null;
        }

        int len = array.length; // 一维长度
        if (0 == len) {
            return null;
        }
        int length = array[0].length; // 二维长度
        if (0 == length) {
            return null;
        }

        int count = 0;
        for (int i = 0; i < len; i++) {
            int[] arr = array[i];
            for (int j = 0; j < length; j++) {
                int ele = arr[j];
                if (defaultValue != ele) {
                    count++;
                }
            }
        }

        int[][] spareArray = new int[1 + count][3];
        spareArray[0][0] = len; // 一维长度
        spareArray[0][1] = length; // 二维长度
        spareArray[0][2] = count; // 非默认元素个数

        int index = 0;
        for (int a = 0; a < len; a++) {
            for (int b = 0; b < length; b++) {
                int ele = array[a][b];
                if (defaultValue != ele) {
                    index++;
                    spareArray[index][0] = a;
                    spareArray[index][1] = b;
                    spareArray[index][2] = ele;
                }
            }
        }

        return spareArray;
    }

    /**
     * 将稀疏数组恢复回普通的二维数组
     */
    public static int[][] recover(int[][] spareArray, int defaultValue) {
        if (null == spareArray) {
            return null;
        }

        int len = spareArray[0][0];
        int length = spareArray[0][1];
        int count = spareArray[0][2];

        int[][] array = new int[len][length];
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < length; j++) {
                array[i][j] = defaultValue;
            }
        }

        for (int a = 1; a <= count; a++) { // 从稀疏数组的第二维开始遍历
            int x = spareArray[a][0];
            int y = spareArray[a][1];
            int ele = spareArray[a][2];
            array[x][y] = ele;
        }

        return array;
    }

}