Java实现稀疏数组

1、概念

如果一个数组(包括多维数组)中的大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，节约空间。

一般来说，稀疏数组的处理方法是：

1.记录数组一共有几行几列，有多少个不同的数值。
2.把具有不同值的元素的行列记录在一个小规模的数组中，从而缩小程序的规模。
如图所示，一般来说，第一行存取几行几列以及几个不同的数值。

2、应用

1、可以使用稀疏数组来保留类似前面的二维数组(棋盘，地图等)。
2、把稀疏数组存盘，并且可以重新恢复原来的二维数组数。

3、Java代码实现

（1）、原始数组转换为稀疏数组 

/***
     * 将原始数组转换为稀疏数组
     * @param arr
     * @return
     */
    private static int[][] arr2SparseArray(int[][] arr){
        int length_hang = arr.length,legtn_lie = arr[0].length,sum = 0;
        //计算非零元素个数
        for (int i = 0; i < length_hang; i++) {
            for (int j = 0; j < legtn_lie; j++) {
                if (0!= arr[i][j]){
                    sum++;
                }
            }
        }
        int[][]sparseArray = new int[sum+1][3];
        //第一行分别代表原始数组的行数、列数和非零元素个数
        sparseArray[0][0] = length_hang;
        sparseArray[0][1] = legtn_lie;
        sparseArray[0][2] = sum;
        //遍历原始数组，记录非零元素的坐标和值
        int inex = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (0!= arr[i][j]){
                    sparseArray[inex][0] = i;
                    sparseArray[inex][1] = j;
                    sparseArray[inex][2] = arr[i][j];
                    inex++;
                }
            }
        }
        return sparseArray;
    }

（2）、稀疏数组恢复为原始数组

/**
     * 稀疏数组恢复原始数组
     * @param sparseArray
     * @return
     */
    private static int[][] sparseArray2Arr(int[][]sparseArray){
        //读取原始数组的行和列（稀疏数组第一行）
        int length_hang = sparseArray[0][0],length_lie = sparseArray[0][1];
        int[][] arr = new int[length_hang][length_lie];
        //从第二行开始遍历稀疏数组，恢复非零元素
        for (int i = 1; i < sparseArray.length; i++) {
                arr[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return arr;
    }

4、测试

public static void main(String[] args) {
        int[][] arr = new int[6][7];
        arr[0][3] = 22;
        arr[0][6] = 15;
        arr[1][1] = 11;
        arr[1][5] = 17;
        arr[2][3] = -6;
        arr[3][5] = 39;
        arr[4][0] = 91;
        arr[5][2] = 28;
        
        System.out.println("=================原始数组===================");
        for (int[] ints : arr) {
            for (int a : ints) {
                System.out.print(a+"	");
            }
            System.out.println();
        }
        System.out.println("==================变换为稀疏数组============");
        int[][]sparseArray = arr2SparseArray(arr);
        for (int[] ints : sparseArray) {
            for (int a : ints) {
                System.out.print(a+"	");
            }
            System.out.println();
        }
        System.out.println("==================恢复为原始数组============");
        int[][] arr1 = sparseArray2Arr(sparseArray);
        for (int[] ints : arr1) {
            for (int a : ints) {
                System.out.print(a+"	");
            }
            System.out.println();
        }
    }

5、结果

=================原始数组===================
0    0    0    22    0    0    15    
0    11    0    0    0    17    0    
0    0    0    -6    0    0    0    
0    0    0    0    0    39    0    
91    0    0    0    0    0    0    
0    0    28    0    0    0    0    
==================变换为稀疏数组============
6    7    8    
0    3    22    
0    6    15    
1    1    11    
1    5    17    
2    3    -6    
3    5    39    
4    0    91    
5    2    28    
==================恢复为原始数组============
0    0    0    22    0    0    15    
0    11    0    0    0    17    0    
0    0    0    -6    0    0    0    
0    0    0    0    0    39    0    
91    0    0    0    0    0    0    
0    0    28    0    0    0    0    

Process finished with exit code 0