Java 稀疏数组

package array;

/**
 * 稀疏数组
 */
public class SparseArray {
    private static int n = 4;
    private static int m = 5;
    private int[][] sparseArray;

    public static void main(String[] args) {
        int[][] ddd;
        int[][] ddd1 = {};
        int[][] ddd2 = {{}};
        int[][] ddd3 = {{},{}};
        int[][] ddd4 = {null, {},{}};
        // must initialized
        //System.out.println(isEmpty(ddd));
        System.out.println(isEmpty(ddd1));
        System.out.println(isEmpty(ddd2));
        System.out.println(isEmpty(ddd3));
        System.out.println(isEmpty(ddd4));
        printArray(ddd2);
        printArray(ddd3);
        printArray(ddd4);

        int[][] array = new int[n][m];
        array[1][1] = 1;
        array[2][3] = 8;
        array[3][4] = 6;

        printArray(array);
        System.out.println(array.length + "");
        int[][] sparseArray = arrayToSparseArray(array);
        printArray(sparseArray);

        System.out.println("------------");

        int[][] originalArray = sparseArrayToArray(sparseArray);
        printArray(originalArray);
    }

    /**
     * 稀疏数组转换为二维数组
     * @param sparseArray
     * @return
     */
    public static int[][] sparseArrayToArray(int[][] sparseArray){
        if(isEmpty(sparseArray)){
            return sparseArray;
        }
        int[][] array = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i){
            array[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return array;
    }
    /**
     * 二维数组转换为稀疏数组
     * @param array n*m
     * @return
     */
    public static int[][] arrayToSparseArray(int[][] array){
        if(isEmpty(array)){
            return array;
        }
        int sum = 0;
        for (int[] row : array){
            for(int data : row){
                if (0 != data){
                    sum++;
                }
            }
        }

        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = getArrayRow(array);
        sparseArray[0][1] = getArrayCol(array);
        sparseArray[0][2] = sum;
        int count = 0;
        for(int i = 0; i //array.length为二维数组的行数row
            for (int j = 0; j //array[i].length为二维数组列数col
                if (0 != array[i][j]){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                }
            }
        }

        return sparseArray;
    }

    /**
     * 获取二维数组列数
     * @param array
     * @return
     */
    public static int getArrayCol(int[][] array){
        if(isEmpty(array)){
            return 0;
        }
        return array[0].length;
    }

    /**
     * 获取二维数组行数
     * @param array
     * @return
     */
    public static int getArrayRow(int[][] array){
        if(isEmpty(array)){
            return 0;
        }
        return array.length;
    }

    /**
     * 打印二维数组
     * @param array
     */
    public static void printArray(int[][] array){
        if(isEmpty(array)){
            return;
        }
        for (int[] row : array){
            for(int data : row){
                System.out.printf("%d ", data);
            }
            System.out.println();
        }
    }

    /**
     * 二维数组判空
     *
     * 考虑下面几种情况
     * int[][] ddd; 没有初始化，不能引用，编译报错must initialized
     * int[][] ddd1 = {};
     * int[][] ddd2 = {{}};
     * int[][] ddd3 = {{},{}};
     * int[][] ddd4 = {null, {},{}};
     * @param array
     * @return
     */
    public static boolean isEmpty(int[][] array){
        if(null == array || 0 == array.length){
            return true;
        }
        for(int i = 0; i ){
            // 有任意值，则不为空
            if(null != array[i] && 0 != array[i].length){
                return false;
            }
        }
        return true;
    }
}