关于稀疏数组实现

关于稀疏数组实现

前言:在五子棋游戏中，通常用数组来表示棋盘，棋盘中用数据来记录棋子的落子位置，我们用到存盘功能，需要将数组的数据写入磁盘，但当棋子（数据）不是很多时，无效数据远大于有效数据时，用原数组对数据进行存储就显得很不划算了，我们可以用稀疏数组来实现对数据的压缩

定义：

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组

			// 二维数组,大小是int[11][11]
			  0 0 0 0 0 0 0 0 0 0 0
              0 0 1 0 0 0 0 0 0 0 0
              0 0 0 0 2 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0

压缩成稀疏数组后：

			  // 二维数组,大小是int[3][3]
	 		  11 11 2    
              1  2  1
              2  4  2

经由上述可发现：普通数组转换成稀疏数组，存储同样的数据，稀疏数组用的小的多
算法规则如下

• 稀疏数组的共有三列，第一行记录的是普通数组的总体属性,分别为行，列，有效数据个数
• 稀疏数组除第一行数据，其他的都记录的是有效数据的属性,第一列记录得为所处的行数，第二列记录的为所处的列数，第三列记录的为数据的值

代码实现：

package com.slp.sparsearray;


/**
 * @program: Basics
 * @description: 稀疏数组实现
 * @author: 十里坡剑神
 **/
public class SparseArray {
    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;
        chessArr1[2][4] = 2;
        // 输出原始的二维数组
        for (int i = 0; i < chessArr1.length; i++) {
            // 遍历得到每一行
            for (int j = 0; j < chessArr1[i].length; j++) {
                // 遍历每一行的每一列
                System.out.printf("%d\t", chessArr1[i][j]);
            }
            System.out.println();
        }

        // 将二维数组 转换 成稀疏数组
        // 1.先遍历二维数组，得到非0的数据的个数
        int sum = 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);
        // 2. 创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        // 给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        // 遍历二维数组,将非0的值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println("得到了稀疏数组");
        for (int i = 0; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr[i].length; j++) {
                System.out.printf("%d\t", sparseArr[i][j]);
            }
            System.out.println();
        }

        /*
         * 将稀疏数组转换成原始的二维数组
         *  11	11	3  有11行，11列，3个有效数据
         *  1	2	1  在第一行，第3列有一个值为1的数据
         *  2	3	2
         *  2	4	2
         * */
        System.out.println("将稀疏数组转换成原始的二维数组");
        // 1. 获得数组矩阵
        int arr[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        // 2. 遍历稀疏数组,为数组矩阵填充有效数据,共有sparseArr[0][2]条有效数据,遍历3次
        for (int i = 1; i < sparseArr.length; i++) {
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.printf("%d\t", arr[i][j]);
            }
            System.out.println();
        }
    }
}
```