使用稀疏数组实现棋盘的存储和读取

1、基本介绍

稀疏数组就是一个二维数组，但它里面存储的是二维数组的行数、列数以及值。

当一个数组中大部分元素为0或者为同一个值的数组时，可以使用稀疏数组保存。

2、处理方法

记录数组一共有几行几列，有多少个不同的值。

把具有不同值的元素的行列以及记录在一个小规模的数组中，从而缩小程序的规模。

3、代码实现

/**
 * 案例：
 * 使用稀疏数组实现围棋的读盘和存盘
 * 棋盘是11*11的二维数组
 */
public class SparseArray {
    public static void main(String[] args) {
        // 创建一个原始二维数组（棋盘）：0表示没有子，1表示黑子，2表示白子（棋子）
        int[][] arr = new int[11][11];
        // 初始化原始数组
        arr[1][2] = 1;
        arr[2][3] = 2;

        SparseArray.write(arr); //调用写盘方法，将二维数组 转换成 稀疏数组
        SparseArray.read(SparseArray.write(arr)); // 调用读盘方法，将稀疏数组 恢复成 二维数组
    }

    /**
     * 写盘
     * 将二维数组 转 稀疏数组的思路
     * 1.遍历原始二维数组，得到有效数据的和。
     * 2.根据有效数据的和创建稀疏数组
     * sparseArr int [sum +1][3]（稀疏数组的行是有效数据个数+1（第一行记录的二维数组的总行数，总列数，总有效数据个数），列是三列（有效数据对应的行数、列数、值）
     * 3.将二维数组的有效数据存入 稀疏数组
     */
    public static int[][] write(int[][] arr) {
        // 输出原始二维数组
        System.out.println("-- 原始二维数组 --");
        for (int[] row : arr) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        // 第一步、统计原始数组里的非零数的个数
        int sum = 0;
        for (int[] row : arr) {
            for (int data : row) {
                if (data != 0) {
                    sum += 1;
                }
            }
        }
        // 第二步、创建对应稀疏数组：行数 列数 值
        int[][] sparseArr = new int[sum + 1][3];
        // 第三步、初始化稀疏数组的第一行
        sparseArr[0][0] = 11; // 二维数组行数
        sparseArr[0][1] = 11; // 二维数组列数
        sparseArr[0][2] = sum; // 二维数组一共的元素数量
        // 第四步、将二维数组 转换成 稀疏数组
        int count = 0; // 用于记录第几个非0数据
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0) { // 遍历二维数组，当二维数组有值时，就将其添加到稀疏数组
                    count++;
                    sparseArr[count][0] = i; // 存放二维数组的元素的行数
                    sparseArr[count][1] = j; // 存放二维数组的元素的列数
                    sparseArr[count][2] = arr[i][j]; // 存放二维数组的值
                }
            }
        }
        // 输出稀疏数组
        System.out.println("-- 稀疏数组 --");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }
        // 返回稀疏数组
        return sparseArr;
    }


    /**
     * 读盘
     * 将稀疏数组 转 二维数组的思路
     * 1.先读取稀疏数组第一行，根据第一行，还原原始二维数组。
     * 2.在读取稀疏数组第一行之后的数据，并赋给原始二维数组。
     */
    public static int[][] read(int[][] sparseArr) {
        // 输出稀疏数组
        System.out.println("-- 稀疏数组 --");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }

        // 第一步、读取稀疏数组的第一行，根据稀疏数组第一行创建原始二维数组
        int[][] arr = new int[sparseArr[0][0]][sparseArr[0][1]];
        // 将读取的稀疏数组的数据（从第二行开始）赋给二维数组
        for (int i = 1; i < sparseArr.length; i++) {
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2]; // arr[稀疏数组存储的行数][稀疏数组存储的列数] = 稀疏数组存储的值
        }

        // 输出稀疏数组恢复后的数组
        System.out.println("-- 二维数组 --");
        for (int[] row : arr) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        // 将二维数组返回
        return arr;
    }
}