稀疏数组

实际的需求

编写一个五子棋程序 使用二维数组 1代表黑子 2代表蓝子 0代表空白处

问题分析

$如上图所示，该二维数组的很多值默认都是0，因此记录了很多没有意义的数据。可以用稀疏数组解决上面的问题$

基本介绍

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

处理方法

1. 记录数组一共有几行几列，有多少个不同的值
2. 具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

举例说明

思路

二维数组转换成稀疏数组

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

稀疏数组转换成二维数组

1. 读取稀疏数组的第一行，根据第一行的数组，创建出二维数组 sparseArr[0][0]是行数 sparseArr[0][1]是列数  sparseArr[0][2]有效数据的个数
2. 读取稀疏数组的后几行数据，赋值给二维数组

实现

public class SparseArrayTest {


    /**
     * @return void
     * @Description: 测试二维数组转稀疏数组
     * @author luoyong
     * @create 11:38 下午 2021/2/2
     * @last modify by [LuoYong 11:38 下午 2021/2/2 ]
     */
    @Test
    public void toSparseArrayTest() {
        //1:创建一个11*11的二维数组
        // 0 表示没有棋子 1表示黑子 2表示白子
        int priChessArr[][] = new int[11][11];
        priChessArr[1][2] = 1;
        priChessArr[2][3] = 2;
        priChessArr[4][5] = 2;
        System.out.println("原始数组是");
        printArray(priChessArr);
        System.out.println("开始转换为稀疏数组");
        int[][] sparseArray = toSparseArray(priChessArr, 0);
        if (null == sparseArray) {
            return;
        }
        System.out.println("打印稀疏数组");
        printArray(sparseArray);

        //将稀疏数组还原成二维数组
        System.out.println("将稀疏数组还原成二维数组");
        int[][] twoDimensionalArray = toTwoDimensionalArray(sparseArray);
        if (null == twoDimensionalArray) {
            return;
        }
        System.out.println("打印稀疏数组还原之后的二维数组");
        printArray(twoDimensionalArray);
    }

    /**
     * @param array
     * @return void
     * @Description: 二维数组打印
     * @author luoyong
     * @create 11:40 下午 2021/2/2
     * @last modify by [LuoYong 11:40 下午 2021/2/2 ]
     */
    private void printArray(int[][] array) {
        for (int[] row : array) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }

    /**
     * @param sparseArray 稀疏数组
     * @return int[][]
     * @Description: 将稀疏数组转换成二维数组
     * @author x
     * @create 11:46 下午 2021/2/2
     * @last modify by [LuoYong 11:46 下午 2021/2/2 ]
     */
    private int[][] toTwoDimensionalArray(int sparseArray[][]) {
        if (null == sparseArray) {
            return null;
        }

        //二维数组初始化
        int[][] twoDimensionalArray = new int[sparseArray[0][0]][sparseArray[0][1]];

        //稀疏数组有效个数
        int effectiveValueNum = sparseArray[0][2];
        if (effectiveValueNum <= 0) {
            return null;
        }

        //有效值赋值
        for (int i = 1; i <= effectiveValueNum; i++) {
            twoDimensionalArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        return twoDimensionalArray;
    }

    /**
     * @param twoDimensionalArray 普通二维数组
     * @param defaults            默认值 一个数组当中大部分数据全是0 那么0就是默认值
     * @return int[][]
     * @Description: 将二维数组转换成稀疏数组
     * @author luoyong
     * @create 10:54 下午 2021/2/2
     * @last modify by [LuoYong 10:54 下午 2021/2/2 ]
     */
    private int[][] toSparseArray(int[][] twoDimensionalArray, int defaults) {
        if (null == twoDimensionalArray) {
            return null;
        }
        //行数
        int rowLength = twoDimensionalArray.length;
        //列数
        int columnLength = twoDimensionalArray[0].length;

        //计算二维数组有效个数 即非默认值
        int effectiveValueNum = countEffectiveValueNum(twoDimensionalArray, defaults);
        if (effectiveValueNum <= 0) {
            return null;
        }

        //创建稀疏数组
        //int[0][0]-->原数组行数 int[0][1]原数组列数  int[0][2]-->原数组有效数据个数
        int sparseArray[][] = new int[effectiveValueNum + 1][3];

        //填充第一行数据
        sparseArray[0][0] = rowLength;
        sparseArray[0][1] = columnLength;
        sparseArray[0][2] = effectiveValueNum;

        //往稀疏数组当中填充数据 row-->行数 因为一行已经存在了数据 所有row的值为1
        int row = 1;
        for (int i = 0; i < twoDimensionalArray.length; i++) {
            for (int j = 0; j < twoDimensionalArray[0].length; j++) {
                if (twoDimensionalArray[i][j] == defaults) {
                    continue;
                }
                //记录行
                sparseArray[row][0] = i;
                //记录列
                sparseArray[row][1] = j;
                //保存行列对应的数据
                sparseArray[row][2] = twoDimensionalArray[i][j];
                row++;
            }
        }
        return sparseArray;
    }

    /**
     * @param twoDimensionalArray 普通二维数组
     * @param defaults            默认值 一个数组当中大部分数据全是0 那么0就是默认值
     * @return int
     * @Description: 计算二维数组有效个数
     * @author luoyong
     * @create 11:07 下午 2021/2/2
     * @last modify by [LuoYong 11:07 下午 2021/2/2 ]
     */
    private int countEffectiveValueNum(int[][] twoDimensionalArray, int defaults) {
        if (null == twoDimensionalArray) {
            return 0;
        }
        //用来存储有效个数
        int count = 0;

        for (int i = 0; i < twoDimensionalArray.length; i++) {
            for (int j = 0; j < twoDimensionalArray[0].length; j++) {
                if (twoDimensionalArray[i][j] != defaults) {
                    count++;
                }
            }
        }
        return count;
    }
}

测试结果截图