关于java:Java中稀疏数组的使用

稠密数组

当一个数组中大部分元素是 0，或者是一个雷同的值时，能够应用稠密数组来保留该数组。并且稠密数组，行数为：原来数组非 0 元素个数 +1；列数为：3。即：稠密数组列数总是 3。

 原数组总行数                原数组总列数               原数组非 0 元素个数
原数组非 0 元素行索引         原数组非 0 元素列索引         原数组非 0 元素值
.
.
.

稠密数组，第一行（即：0 行），第一列存储原数组的总行数，第二列存储原数组的总列数，第三列存储非零元素的数量；其余行构造雷同，每一行存储一条非 0 元素信息。

代码如下

 public static void main(String[] args) {System.out.println("原来数组为：");
        int[][] array1 = new int[5][6];
        array1[1][3] = 4;
        array1[3][4] = 6;
        int sum = 0;// 非 0 的元素个数
        for (int[] arrays : array1) {for (int array : arrays) {System.out.print(array + "\t");
                if (array != 0) {sum++;}
            }
            System.out.println();}
        System.out.println("原来数组中，非 0 的元素个数为：" + sum);

        System.out.println("稠密数组为：");
        int[][] array2 = new int[sum + 1][3];// 稠密数组，sum+ 1 行，3 列

        array2[0][0] = array1.length;// 稠密数组第一行第一列：原数组行数
        array2[0][1] = array1[0].length;// 稠密数组第一行第二列：原数组列数
        array2[0][2] = sum;// 稠密数组第一行第三列：原数组中非 0 的元素个数

        int count = 0;// 非 0 的元素个数，即稠密数组所在行索引
        for (int i = 0; i < array1.length; i++) {for (int j = 0; j < array1[i].length; j++) {if (array1[i][j] != 0) {
                    count++;// 稠密数组所在行索引
                    array2[count][0] = i;// 稠密数组第 count 行第一列，是原数组非 0 的元素的所在行索引
                    array2[count][1] = j;// 稠密数组第 count 行第二列，是原数组非 0 的元素的所在列索引
                    array2[count][2] = array1[i][j];// 稠密数组第 count 行第三列，是原数组非 0 的元素值
                }
            }
        }

        printArray(array2);// 输入稠密数组

        System.out.println("将稠密数组还原成失常数组为：");

        // 定义二维数组，稠密数组第一行第一列：原数组行数，第一行第二列：原数组列数
        int[][] array3 = new int[array2[0][0]][array2[0][1]];// 数组初始化后，每个元素都为 0
        for (int i = 1; i < array2.length; i++) {
            // 从稠密数组，第二行开始遍历，即 i 为 1
            array3[array2[i][0]][array2[i][1]] = array2[i][2];// 稠密数组第 i 行第一列是原数组非 0 元素的行索引，第 i 行第二列是原数组非 0 元素的列索引，第 i 行第三列的值是原数组的元素值
        }

        printArray(array3);// 输入还原后的数组
    }

    private static void printArray(int[][] arrays) {for (int[] array : arrays) {for (int num : array) {System.out.print(num + "\t");
            }
            System.out.println();}
    }

输入后果如下

 原来数组为：0    0    0    0    0    0    
0    0    0    4    0    0    
0    0    0    0    0    0    
0    0    0    0    6    0    
0    0    0    0    0    0    
原来数组中，非 0 的元素个数为：2
稠密数组为：5    6    2    
1    3    4    
3    4    6    
将稠密数组还原成失常数组为：0    0    0    0    0    0    
0    0    0    4    0    0    
0    0    0    0    0    0    
0    0    0    0    6    0    
0    0    0    0    0    0