Java数据结构—稀疏数组

问题引入

要用一个数组将下图所示情况进行抽象表示

可以用如下一个数组进行表示

但这样的弊端很明显：重复的0元素太多并且得到11*11的一个庞大的矩阵
所以可以引入稀疏数组简化数据的表示：

row	col	val
11	11	2
1	2	1
2	3	2

这样就得到了一个3*3的矩阵，这个数组表示较前者简洁许多

二维数组与稀疏数组

二维→稀疏

1. 遍历原始的二维数组，得到有效数据的个数sum
2. 根据sum创建sparseArr int[sum+1][3]
3. 将二维数组的有效数据存入到稀疏数组中

代码实现

 public class sparesArr {
    public static void main(String[] args) {
        //创建一个原始的二维数组
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        for(int[] row : chessArr1){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for(int i =0;i<11;i++){
            for(int j = 0;j<11;j++){
                if(chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }
        //创建对应的稀疏数组
        int sparesArr[][] = new int[sum + 1][3];
        //给稀疏数组赋值
        sparesArr[0][0] = 11;
        sparesArr[0][1] = 11;
        sparesArr[0][2] = sum;
        //遍历二维数组，将非0的值存放到sparseArr中
        int count = 0 ;
        for(int i = 0;i<11;i++){
            for(int j = 0;j<11;j++){
                if(chessArr1[i][j] != 0){
                    count++;
                    sparesArr[count][0] = i;
                    sparesArr[count][1] = j;
                    sparesArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组的形式
        System.out.println();
        System.out.println("稀疏数组：");
        for(int i= 0;i<sparesArr.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparesArr[i][0],sparesArr[i][1],sparesArr[i][2]);
        }
    }
}

稀疏→二维

1.先读取稀疏数组的第1行 ,根据第1行的数据创建原始的二维数组
2.再读取稀疏数组后几行的数据，并赋给原始的二维数组即可

代码实现

public class sparesArr {
    public static void main(String[] args) {
        //创建一个原始的二维数组
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        for(int[] row : chessArr1){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for(int i =0;i<11;i++){
            for(int j = 0;j<11;j++){
                if(chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }
        //创建对应的稀疏数组
        int sparesArr[][] = new int[sum + 1][3];
        //给稀疏数组赋值
        sparesArr[0][0] = 11;
        sparesArr[0][1] = 11;
        sparesArr[0][2] = sum;
        //遍历二维数组，将非0的值存放到sparseArr中
        int count = 0 ;
        for(int i = 0;i<11;i++){
            for(int j = 0;j<11;j++){
                if(chessArr1[i][j] != 0){
                    count++;
                    sparesArr[count][0] = i;
                    sparesArr[count][1] = j;
                    sparesArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组的形式
        System.out.println();
        System.out.println("稀疏数组：");
        for(int i= 0;i<sparesArr.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparesArr[i][0],sparesArr[i][1],sparesArr[i][2]);
        }
        ///***将稀疏数组恢复成原始的二维数组***///
        //1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int chessArr2[][] = new int[sparesArr[0][0]][sparesArr[0][1]];
        //2、读取稀疏数组后几行的数据，赋给原始的二维数组即可
        for(int i = 1;i< sparesArr.length;i++){
            chessArr2[sparesArr[i][0]][sparesArr[i][1]] = sparesArr[i][2];
        }
        //输出恢复后的二维数组
        System.out.println();
        System.out.println("恢复后的二维数组：");
        for(int[] row : chessArr2){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

课后练习

要求:
1)在前面的基础上，将稀疏数组保存到磁盘上，比如map.data
2)恢复原来的数组时，读取map.data 进行恢复