矩阵压缩以及将矩阵复原

压缩存储的基本思想主要有两个：

        为多个值相同的元素只分配一个存储空间；对零元素不分配存储空间。对于稀疏矩阵的压缩存储，通常只存储非0元素，并需同时存储该元素所在矩阵中的行标和列标。

       除此之外，还需要存储矩阵的行数和列数。 

 

 public static void main(String[] args) {
        //创建一个原始数组 11*11
        //0代表没有棋子，1表示黑子 2表示篮子
        int chessArray[][] = new int[11][11];
        chessArray[1][2] = 1;
        chessArray[2][3] = 2;
        System.out.println("======原始的二维数组======");

        //打原始数组并且统计压缩的元素个数
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                System.out.printf("%d\t", chessArray[i][j]);
                if (chessArray[i][j] != 0) {
                    sum++;
                }
            }
            System.out.println();
        }
        System.out.println("统计元素的个数为" + sum);

        //现在将元素转化为稀疏数组
        int[] spaceArray[] = new int[sum + 1][3];
        spaceArray[0][0] = 11;
        spaceArray[0][1] = 11;
        spaceArray[0][2] = sum;
        int count = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0) {
                    count++;
                    spaceArray[count][0] = i;
                    spaceArray[count][1] = j;
                    spaceArray[count][2] = chessArray[i][j];
                }
            }
        }
        //打印稀疏数组
        System.out.println("=========稀疏矩阵========");
        for (int[] row : spaceArray) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //通过稀疏数组输出原始数组
        int row = spaceArray[0][0];
        int col = spaceArray[0][1];
        int[] orignalArray[] = new int[row][col];


        //将稀疏矩阵的值赋给原始数组originalArray
        for (int i = 0; i < orignalArray.length; i++) {
            for (int j = 0; j < orignalArray.length; j++) {
                //在这里需要判断spaceArray的元素有几个spaceArray.length-1
                if (i < spaceArray.length-1) {
                    orignalArray[spaceArray[i + 1][0]][spaceArray[i + 1][1]] = spaceArray[i + 1][2];
                }
            }
        }

        //遍历稀疏矩阵转化的二维数组
        System.out.println("=======恢复稀疏数组======");
        for (int[] rowOri : orignalArray) {
            for (int data : rowOri) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }

或者将压缩后数组中的值一个个取出：

    public static void main(String[] args) {
        //创建一个原始数组 11*11
        //0代表没有棋子，1表示黑子 2表示篮子
        int chessArray[][] = new int[11][11];
        chessArray[1][2] = 1;
        chessArray[2][3] = 2;
        System.out.println("======原始的二维数组======");
        //打原始数组并且统计压缩的元素个数
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                System.out.printf("%d\t", chessArray[i][j]);
                if (chessArray[i][j] != 0) {
                    sum++;
                }
            }
            System.out.println();
        }
        System.out.println("统计元素的个数为" + sum);

        //现在将元素转化为稀疏数组
        int[] spaceArray[] = new int[sum + 1][3];
        spaceArray[0][0] = 11;
        spaceArray[0][1] = 11;
        spaceArray[0][2] = sum;
        int count = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0) {
                    count++;
                    spaceArray[count][0] = i;
                    spaceArray[count][1] = j;
                    spaceArray[count][2] = chessArray[i][j];
                }
            }
        }
        //打印稀疏数组
        System.out.println("=========稀疏矩阵========");
        for (int[] row : spaceArray) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //通过稀疏数组输出原始数组
        int row = spaceArray[0][0];
        int col = spaceArray[0][1];
        int[] orignalArray[] = new int[row][col];


        //将稀疏矩阵的值赋给原始数组originalArray
        for (int m = 0; m < spaceArray.length; m++) {
            for (int n = 0; n < 3; n++) {
                //寻找数据元素记录当前值

                //稀疏矩阵的列值
                int innerRow = 0;
                int innerCol = 0;
                int val = 0;
                for (int i = 1; i < spaceArray.length; i++) {
                    for (int j = 0; j < spaceArray.length; j++) {
                        innerRow = spaceArray[i][0];
                        innerCol = spaceArray[i][1];
                        val = spaceArray[i][2];
                        orignalArray[innerRow][innerCol] = val;
                    }
                }
            }
        }

        //遍历稀疏矩阵转化的二维数组
        System.out.println("=======恢复稀疏数组======");
        for (int[] rowOri : orignalArray) {
            for (int data : rowOri) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

控制台输出：