二维数组与稀疏数组之间的转换

// 稀疏数组的应用 [棋盘,地图]

// 在写入文件【存档】时把二维数组转换为稀疏数组

// 在读文件【读档】时把文件转换为普通的二维数组

/*《-二维数组转化为稀疏数组的思路-》*/
/**************
 * 1.遍历 原始的二维数组,得到有效的数据个数 sum
 * 2.根据sum 就可以创建稀疏数组 sparrseArr int[sum+1][3]
 * 3.将二维数组的有效数据存放到稀疏数组中
 ***************/

/*《-稀疏数组转化为原始的二维数组-》*/

/*************
 *
 * 1.根据稀疏数组第一行数据创建原始的二维数组
 * 2.读取稀疏数组的后几行数据,并赋值给原始的二维数组
 *
 ***********/

 代码如下：

package data_structure_01;

/**
 * @author 不存在的骑士~
 **/
// 稀疏数组的应用 [棋盘,地图]
// 在写入文件【存档】时把二维数组转换为稀疏数组
// 在读文件【读档】时把文件转换为普通的二维数组

/*《-普通的二维数组转化为稀疏数组的思路-》*/
/**************
 * 1.遍历 原始的二维数组,得到有效的数据个数 sum
 * 2.根据sum 就可以创建稀疏数组 sparrseArr int[sum+1][3]
 * 3.将二维数组的有效数据存放到稀疏数组中
 ***************/

/*《-稀疏数组转化为原始的二维数组-》*/

/*************
 *
 * 1.根据稀疏数组第一行数据创建原始的二维数组
 * 2.读取稀疏数组的后几行数据,并赋值给原始的二维数组
 *
 ************/

@SuppressWarnings("all")
public class Sparse_arrays {
    public static void main(String[] args) {
        // 创建一个 11 行, 11列,的原始二维数组
        // 0 表示 没有棋子 , 1 表示 黑子 , 2 表示 白子

        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        System.out.println("原始的二维数组~~");
        for (int[] ints : chessArr1) {
            for (int data : ints) {
                System.out.printf("%d\t", data);
            }
            System.out.println("");
        }
        //1.遍历 原始的二维数组,得到有效的数据个数 sum
        int sum = 0; // 记录原始二维数组中不为 0 的值

        for (int i = 0; i < 11; i++) { // 控制行
            for (int j = 0; j < 11; j++) { //控制列
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("sum= " + sum);
        //  2.根据sum 就可以创建稀疏数组 sparrseArr int[sum+1][3]
        int[][] sparrseArr = new int[sum + 1][3]; // 稀疏数组

        //  3.给稀疏数组赋值
        // 3.1 将原始数组的信息赋给稀疏数组的第一行
        sparrseArr[0][0] = 11;
        sparrseArr[0][1] = 11;
        sparrseArr[0][2] = sum;

        // 3.2遍历二维数组将二维数组的有效数据存放到稀疏数组中
        int count = 0; // 用于记录是第几个非 0 的数据
        for (int i = 0; i < 11; i++) { // 控制行
            for (int j = 0; j < 11; j++) { //控制列
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparrseArr[count][0] = i;
                    sparrseArr[count][1] = j;
                    sparrseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println();

        System.out.println("得到的稀疏数组是~~~~");

        for (int i = 0; i < sparrseArr.length; i++) {

            System.out.printf("%d\t%d\t%d\t\n", sparrseArr[i][0], sparrseArr[i][1], sparrseArr[i][2]);
        }
        System.out.println();

        // 将 稀疏数组 转化为 普通的二维数组
        // 1.利用 稀疏数组保存的 原始的二维数组信息建立一个二维数组
        int[][] chessArr2 = new int[sparrseArr[0][0]][sparrseArr[0][1]];
        // 2.遍历稀疏数组给二维数组赋值【利用稀疏数组保存的原始数组有效值的下标信息】
        for (int i = 1; i < sparrseArr.length; i++) {
            chessArr2[sparrseArr[i][0]][sparrseArr[i][1]] = sparrseArr[i][2];
        }

        System.out.println("还原后的原始数组~~~");
        for (int[] ints : chessArr2) {
            for (int data : ints) {
                System.out.printf("%d\t", data);
            }
            System.out.println("");
        }


    }
}