数据结构学习--稀疏数组

稀疏数组

       当二维数组中的有效数据较小时，为了减少保存该数组所占用的内存空间，通常将原始数组转换为稀疏数组进行存储，一般流程为：二维数组->稀疏数组->序列化到硬盘->反序列化到内存->读取稀疏数组->读取二维数组。 ​

       二维数组转稀疏数组的过程： ​ 1.遍历原始二维数组，得到有效数据的个数sum； ​ 2.根据sum创建稀疏数组sparseArr，该稀疏数组有sum+1行，3列，其中第一行记录原始数组的大小和有效值个数，从第二行开始每列记录该数据的行号，列号及值； ​ 3.将二维数组的有效数据存入到稀疏数组中。 ​

       稀疏数组转原始数组的过程： ​ 1.先读取稀疏数组第一行，创建原始数组； ​ 2.在读取稀疏数组后几行的数组，并赋值给原始数组。 ​

       整个流程的代码SparseArrayPrinciple如下:

/**
 * 稀疏数组原理
 *
 * @author limin
 * @date 2020/11/14
 */
public class SparseArrayPrinciple {
    /**
     * 原始数组转稀疏数组
     * */
    public int[][] transToSparseArray(int[][] originalArray) {
        // 1.遍历原始数组，获取有效数据个数
        int validDataNum = getValidDataNum(originalArray);
        // 2.创建稀疏数组
        int[][] sparseArray = createSparseArray(validDataNum);
        // 3.为稀疏数组赋值
        setValidDataIntoSparseArray(originalArray, sparseArray, validDataNum);
        return sparseArray;
    }

    private void setValidDataIntoSparseArray(int[][] originalArray, int[][] sparseArray, int validDataNum) {
        // 1.稀疏数组第一行记录原始数组大小及有效数据个数
        sparseArray[0][0] = originalArray.length;
        sparseArray[0][1] = originalArray[0].length;
        sparseArray[0][2] = validDataNum;
        // 2.将数据在原始数组的位置和值记录到稀疏数组中
        int sparseArrayRow = 0;
        for (int i = 0; i < originalArray.length; i++) {
            for (int j = 0; j < originalArray[i].length; j++) {
                if (originalArray[i][j] != 0) {
                    sparseArrayRow++;
                    sparseArray[sparseArrayRow][0] = i;
                    sparseArray[sparseArrayRow][1] = j;
                    sparseArray[sparseArrayRow][2] = originalArray[i][j];
                }
            }
        }
    }

    private int[][] createSparseArray(int sum) {
        // 稀疏数组有sum+1行，3列
        int[][] sparseArray = new int[sum + 1][3];
        return sparseArray;
    }

    private int getValidDataNum(int[][] originalArray) {
        int validDataNum = 0;
        for (int i = 0; i < originalArray.length; i++) {
            for (int j = 0; j < originalArray[i].length; j++) {
                if (originalArray[i][j] != 0) {
                    validDataNum++;
                }
            }
        }
        return validDataNum;
    }

    /**
     * 稀疏数组转原始数组
     * */
    public int[][] transToOriginalArray(int[][] sparseArray) {
        // 1.读取稀疏数组第一行，创建原始数组
        int[][] originalArray = createOriginalArray(sparseArray);
        // 2.为原始数组赋值
        setDataIntoOriginalArray(originalArray, sparseArray);
        return originalArray;
    }

    private void setDataIntoOriginalArray(int[][] originalArray, int[][] sparseArray) {
        for (int i = 1; i < sparseArray.length; i++) {
            originalArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
    }

    private int[][] createOriginalArray(int[][] sparseArray) {
        int[][] originalArray = new int[sparseArray[0][0]][sparseArray[0][1]];
        return originalArray;
    }
}

       测试代码SparseArrayPrincipleTest如下：

/**
 * 稀疏数组创建与还原测试类
 *
 * @author limin
 * @date 2020/11/14
 */
public class SparseArrayPrincipleTest {
    public static void main(String[] args) {
        createSparseArrayFromOriginalArrayTest();
        System.out.println("============this is a diving line===============");
        createOriginalArrayFromSparseTest();
    }

    private static void createSparseArrayFromOriginalArrayTest() {
        System.out.println("create sparse array test: ");
        SparseArrayPrinciple sparseArrayPrinciple = new SparseArrayPrinciple();
        int[][] originalArray = new int[][]{{0, 0, 0, 3}, {0, 2, 0, 0}, {0, 0, 7, 0}, {0, 0, 0, 0}};
        System.out.println("original array is: ");
        printArray(originalArray);
        System.out.println("test result: sparse array is: ");
        int[][] sparseArray = sparseArrayPrinciple.transToSparseArray(originalArray);
        printArray(sparseArray);
    }

    private static void createOriginalArrayFromSparseTest() {
        System.out.println("create original array test: ");
        SparseArrayPrinciple sparseArrayPrinciple = new SparseArrayPrinciple();
        int[][] sparseArray = new int[][]{{4, 4, 3}, {0, 3, 3}, {1, 1, 2}, {2, 2, 7}};
        System.out.println("sparse array is: ");
        printArray(sparseArray);
        System.out.println("test result: original array is: ");
        int[][] originalArray = sparseArrayPrinciple.transToOriginalArray(sparseArray);
        printArray(originalArray);
    }

    public static void printArray(int[][] originalArray) {
        for (int i = 0; i < originalArray.length; i++) {
            for (int j = 0; j < originalArray[i].length; j++) {
                System.out.print(originalArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

       测试结果如下：

create sparse array test: 
original array is: 
0 0 0 3 
0 2 0 0 
0 0 7 0 
0 0 0 0 
test result: sparse array is: 
4 4 3 
0 3 3 
1 1 2 
2 2 7 
============this is a diving line===============
create original array test: 
sparse array is: 
4 4 3 
0 3 3 
1 1 2 
2 2 7 
test result: original array is: 
0 0 0 3 
0 2 0 0 
0 0 7 0 
0 0 0 0