数据结构与算法--第1篇（稀疏数组）

一，稀疏数组

1，简介：

稀疏数组：是以某个重复出现的二维数组的值为基准，进行隐藏式压缩成n行（n=原二维数组中不同值得个数） x 3列的二维数组；
如下图：二维数组 转 稀疏数组

2，分析：

列数 == 3；
行数 = 二维数组中有效数字（如上图：除0之外的数）之外的总个数（如上图：为22,15,11…91,28的总个数=8）；
所以形成的稀疏数组为3*8=24的新二维数组；
原二维数组：6*7=42，可见空间上有了一定的减少；

第0行：稀疏数组的【0】

row（行）：记录的原二维数组的行数=6行；
col（列）：记录的原二维数组的列数=7列；
val（值）：记录的原二维数组的有效数字的总个数（如上图：为22,15,11…91,28的总个数=8），也定义了除【0】行之外的其余行的数量（为8行）；

第1行：稀疏数组的【1】

row（行）：记录的原二维数组的第一个有效数字的行位置（按照下标方式，从0开始，图示第一个其他数为22，在原二维数组第0行）；
col（列）：记录的原二维数组的第一个有效数字的列位置（按照下标方式，从0开始，图示第一个其他数为22，在原二维数组第3列）；
val（值）：记录的原二维数组的第一个有效数字的值22（图示第一个其他数为22）；
综上：第一个有效数字的行信息为：【1】0 3 22
其他7行以此类推，得到稀疏数组

3，二维数组 转 稀疏数组

1. 遍历原二维数组得到有效数字的个数sum（上图sum=8）；
2. 创建稀疏数组sparseArr，如int[sum+1] [[3]]的二维数组；
3. 将二维数组的有效数字按照上面方式存入稀疏数组，达到减少空间效果；

4，稀疏数组 还原 二维数组

1. 先读取稀疏数组第一行数据，根据行和列创建二维数组，如int[6][7]；
2. 再读取其余行数据根据下标放入对应的二维数组中去，达到还原效果；

对于此类数组存盘操作情况下可以很好的做的高效和压缩。

5，示例代码：

package com.data;

/**
 * @param
 * @Author: AaNeei
 * @Date: 2019/6/11  23:00
 * @Description: 游学网
 * @throws:
 */
public class SparseArr {

    public static void main(String[] args) {

        //二维数组初始化
        int[][] doubleDimensionalArray = initDoubleDimensionalArray(6, 7);
        System.out.println("====================二维数组转稀疏数组============================");
        //转稀疏数组
        int[][] sparseArr = doubleDimensionalArrayToSparseArr(doubleDimensionalArray);
        System.out.println("====================稀疏数组还原二维数组============================");
        //稀疏数组还原二维数组
        int[][] dimensionalArray = sparseArrRestoreDoubleDimensionalArray(sparseArr);
    }

    private static int[][] sparseArrRestoreDoubleDimensionalArray(int[][] sparseArr) {
        int[][] doubleDimensionalArray=new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            doubleDimensionalArray[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        for (int[] ints : doubleDimensionalArray) {
            for (int data : ints) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        return doubleDimensionalArray;
    }

    private static int[][] doubleDimensionalArrayToSparseArr(int[][] doubleDimensionalArray) {
        int sum = 0;
        for (int[] ints : doubleDimensionalArray) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
            }
        }
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = doubleDimensionalArray.length;
        sparseArr[0][1] = doubleDimensionalArray[0].length;
        sparseArr[0][2] = sum;
        //将非0的值存入稀疏数组
        int count = 0;
        for (int i = 0; i < doubleDimensionalArray.length; i++) {
            for (int j = 0; j < doubleDimensionalArray[0].length; j++) {

                if (doubleDimensionalArray[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = doubleDimensionalArray[i][j];
                }

            }
        }
        //打印稀疏数组
        for (int[] ints : sparseArr) {
            for (int data : ints) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }


        return sparseArr;
    }

    private static int[][] initDoubleDimensionalArray(int row, int col) {
        int[][] doubleDimensionalArray = new int[row][col];
        doubleDimensionalArray[0][3] = 22;
        doubleDimensionalArray[0][6] = 15;
        doubleDimensionalArray[1][1] = 11;
        doubleDimensionalArray[1][5] = 17;
        doubleDimensionalArray[2][3] = -6;
        doubleDimensionalArray[3][5] = 39;
        doubleDimensionalArray[4][0] = 91;
        doubleDimensionalArray[5][2] = 28;
        System.out.println("原二维数组：");
        for (int[] ints : doubleDimensionalArray) {
            for (int data : ints) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        return doubleDimensionalArray;
    }
}