场景分析：

编写一个五子棋程序，要求做到存盘和续上局的功能。见图1所示一个棋盘。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ??

那么如何做到存盘呢？

可以利用二维数组对棋盘进行映射，如图二。通过存放不同的两个值来代表黑子和蓝子，当需要存盘时，我们只需要保存一下这个二位数组，以便续上局时读取出来，在映射为棋盘。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

但是问题来了，由图二我们可以看出除了用1，2代表的黑子和蓝子外，数组其他位置都是用0来填充，实际上这些0并无实际意义。由此我们可以将二维数组转为稀疏数组。

案例：

原始数组：

?

转换稀疏数组：

转换思路：

1.二维数组转换为稀疏数组

? ? 1）对二维数组进行遍历，得到有效数据的个数sum

? ? 2) 创建一个稀疏数组sparseArr int[sum+1][3]

? ? 3) 存入有效数据值

2.稀疏数组转为二位数组

? ? 1）读取稀疏数组第一行，获取原始数组行列数m,n，创建二维数组int[m][n]

? ? 2) 读取后面数据，依次存入数组。

代码实现：

二维数组转换为稀疏数组：

/**
 * 二维数组转换为稀疏数组
 * 实现思路
 * 1） 对二维数组进行遍历，得到有效数据的个数sum
 * 2)  创建一个稀疏数组sparseArr int[sum+1][3]
 * 3)  存入有效数据值
 */
public class TwoDimensionalArrayToSparseArr {
    public static void main(String[] args) {
        // 1.首先定义一个二维数组,11*11
        int[][] twoDimensionalArray = new int[11][11];

        // 2.给二维数组赋值
        twoDimensionalArray[1][2] = 1;
        twoDimensionalArray[2][3] = 2;

        System.out.println("打印二维数组：");
        for (int [] row : twoDimensionalArray){
            for (int val : row){
                System.out.printf("%d\t",val);
            }
            System.out.println();
        }

        // 3.遍历数组获得非0总数
        int num = 0;
        for (int i=0; i<11; i++){
            for (int j=0; j<11; j++){
                if(twoDimensionalArray[i][j] != 0){
                    num++;
                }
            }
        }

        // 4.创建稀疏数组
        int[][] sparseArr = new int[num+1][3];

        // 5.为数组第一行赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = num;

        // 6.为后续赋值
        int count = 0;
        for (int i=0; i<11; i++){
            for (int j=0; j<11; j++){
                if(twoDimensionalArray[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = twoDimensionalArray[i][j];
                }
            }
        }

        // 7.打印稀疏数组
        System.out.println("打印稀疏数组:");
        for(int i=0; i<num+1; i++){
            for(int j=0; j<3; j++){
                System.out.printf("%d\t",sparseArr[i][j]);
            }
            System.out.println();
        }

    }
}

?

打印结果：

? ? ? ? ? ? ? ? ???

稀疏数组转为二维数组：

/**
 *  稀疏数组恢复为二维数组
 *  实现思路：
 *  1）读取稀疏数组第一行，获取原始数组行列数m,n，创建二维数组int[m][n]
 *  2)  读取后面数据，依次存入数组。
 */
public class SparseArrToTwoDimensionalArray {

    public static void main(String[] args) {
        //1.定义并初始化稀疏数组
        int[][] sparseArr = new int[3][3];

        // 2.赋值
        sparseArr[0][0] = 11;sparseArr[0][1] = 11;sparseArr[0][2] = 2;
        sparseArr[1][0] = 1;sparseArr[1][1] = 2;sparseArr[1][2] = 1;
        sparseArr[2][0] = 2;sparseArr[2][1] = 3;sparseArr[2][2] = 2;

        // 3.打印稀疏数组
        System.out.println("打印稀疏数组:");
        for(int i=0; i<3; i++){
            for(int j=0; j<3; j++){
                System.out.printf("%d\t",sparseArr[i][j]);
            }
            System.out.println();
        }

        // 4。根据稀疏数组的第一行创建原始二位数组
        int[][] twoDimensionalArray = new int[sparseArr[0][0]][sparseArr[0][1]];

        // 5 赋值其他非0值
        for(int i=1; i<sparseArr.length; i++){
            twoDimensionalArray[i][sparseArr[i][1]] = sparseArr[i][2];
        }

        // 6.打印原始二位数组
        System.out.println("打印原始二位数组:");
        for(int i=0; i<twoDimensionalArray.length; i++){
            for(int j=0; j<twoDimensionalArray[i].length; j++){
                System.out.printf("%d\t",twoDimensionalArray[i][j]);
            }
            System.out.println();
        }
    }
}

打印结果：

? ? ? ? ? ? ? ? ?

?

cs