Java稀疏数组

public class ArrayDemo8 {
    /**
     * 稀疏数组
     * 当一个数组中大多数元素为0或同一个值，可以用稀疏数组来保存这个数组
     * 稀疏数组的处理方式
     *      1.记录数组一共有几行激烈，有多少个不同值
     *      2.把具有不同值的元素和行列以及值记录在一个小规模的数组中，从而缩小数组的规模
     *          原始数组                       稀疏数组
     *                                      行   列   值
     *                                   0  6    7    8
     *      0 0 0 22 0 0 15              1  0    3    22
     *      0 11 0 0 0 17 0       *      2  0    6    15
     *      0 0 0 -6 0 0 0    ===== *    3  1    1    11
     *      0 0 0 0 0 39 0    ===== *    4  1    5    17
     *      91 0 0 0 0 0 0        *      5  2    3    -6
     *      0 0 28 0 0 0 0               6  3    5    39
     *                                   7  4    0    91
     *                                   8  5    2    28
     *
     *   右侧第一行记录原始数组的行列值以及有多少个不同的值
     *   其他数据记录的是原始数组不同值的行列值和本身的值
     */

    public static void main(String[] args) {
        //1.创建一个二位数组 6*7的数组并附上值
        int[][] array = new int[6][7];
        array[0][3] = 22;
        array[0][6] = 15;
        array[1][1] = 11;
        array[1][5] = 17;
        array[2][3] = -6;
        array[3][5] = 39;
        array[4][0] = 91;
        array[5][2] = 22;

        //2.打印这个数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }

        //3.转换为稀疏数组
        //需要先获取原始数组中有多少个不同的值
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    sum = sum + 1;
                }
            }
        }
        System.out.println("原始数组中有"+sum+"个不同值");
        int[][] array2 = new int[sum+1][3];
        //获取稀疏数组头部的值
        array2[0][0] = array.length;
        array2[0][1] = array[0].length;
        array2[0][2] = sum;


        //将原始数组不同元素的 行列值以及本身值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    //因为稀疏数组头部 array2[0][..] 被占用了 count 技术需要从0开始
                    //剩下的元素记录的是原始数组的行列值和本身值 每出现一个记录一个 从array2[1][..]开始
                    count = count + 1;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }
        }

        System.out.println();
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }

        //稀疏数组还原
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
                array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }
        System.out.println("=========================");
        //打印还原数组
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[i].length; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
    }
}