数据结构和算法——稀疏数组

项目介绍

在实际项目开发中，经常会遇到保存当前状态的问题。例如写一个棋盘，扫雷，俄罗斯方块之类的游戏，会涉及到暂停保存当前游戏状态并可以读取状态的功能。这时候就需要一个二维数组来记录每一个数据的位置，每一个有棋子、雷或者方块的地方都要进行标记。下面我们用五子棋的棋盘来具体实现一下存盘退出和读取存盘的功能，并对其进行优化。

稀疏数组实现五子棋存盘和读取

实例：数组表示五子棋棋盘
功能：存盘退出，续上局

方法：使用二维数组记录棋盘

将棋盘转化为二维数组的操作很简单，但是有一个问题需要思考：二维数组中很多值是默认值0，也就是二维数组记录了很多没有意义的数据，浪费空间，增加计算机负担，减慢运行速度。

优点：简单直观，操作便捷
缺点：许多棋局只有极少量有效数据，但每次存储都要将整个棋盘存储下来，记录了很多无效数据，浪费空间，降低IO效率。

如何才能解决这个问题呢？

改进方法：将得到的二维数组进一步转化为稀疏数组

1. 稀疏矩阵：在矩阵中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵。
2. 稀疏数组：稀疏数组可以看做是普通数组的压缩。普通数组中的无效数据的数量远远大于有效数据。
3. 稀疏数组的作用：压缩空间，节省存储空间，使每次计算都是对有效数据的操作，节省计算机资源，提高运行速度和IO效率。
4. 稀疏数组的表示方法：
   
   稀疏数组总是一个行不确定（有效数据数+1），列为3列的动态数组。3列分别为“行”、“列”和“值”。
   稀疏数组中，值（蓝色）部分：
   第一行：原始数组有11行11列，一共两个有效值。
   第二行：第一个有效值在原始数组中所处行列（从0开始算，所以“1”代表第二行）为第2行第3列。
   第三行：第二个有效值在原始数组中所处行列为第3行第4列。
5. 二维数组转化为稀疏数组：
   
   单从这个例子来看，如果存储整个二维数组，要记录11×11=121个数，而采用稀疏矩阵就只需要存储3×3=9个数，大大减少了需要存储的数，减轻了计算机工作量，提高了IO效率。

稀疏数组转换的思路分析

二维数组转稀疏数组

1. 遍历原始二维数组，得到有效数据的个数sum。
2. 根据sum就可以创建稀疏数组sparseArr int[sum + 1][3]。
3. 将二维数组的有效数据以及有效数据所在的行列分别存入稀疏数组。

稀疏数组转原始数组

1. 读取稀疏数组第一行，根据第一行的行列值创建原始数组。例如上面实例：chessArr = int[11][11]。
2. 依次读取稀疏数组后几行数据，并根据行列值赋值给创建好的原始数组。

代码实现

输出原始二维数组

创建一个11×11的原始二维数组作为数据源。

		/*
        创建一个原始的二维数组11 * 11
         */
        //0:表示没有棋子，1:表示黑子,2:表示蓝子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组是：");
        for (int[] row : chessArr1){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

原始二维数组打印结果：

原始的二维数组是：
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	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	0	

二维数组转稀疏数组

遍历原始二维数组，分别获取稀疏数组需要的有效值以及有效值的行列信息。

        /*
        将二维数组 转 稀疏数组的思路
         */
        //1.先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < chessArr1.length; i++){
            for (int j = 0; j < 11; j++){
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }

        //2.创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //3.再次遍历二维数组，将非0值存放到sparseArr中
        int count = 0; //count用于记录是第几个非0数据
        for (int i = 0; i < chessArr1.length; 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];
                }
            }
        }

        //4.输出稀疏数组
        System.out.println();
        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]);
        }
        System.out.println();

稀疏数组打印结果：

得到的稀疏数组为：
11	11	2	
1	2	1	
2	3	2

*写盘操作

通过java的IO流，将稀疏数组存入磁盘。

    //新建一个文本文档用于接收需要存入的数据
    File file = new File("sparseArr.txt");
    //判断该文件名是否存在，否则报错并提示创建新文件
    if(!file.exists()){
        file.createNewFile();
    }
    //文件不存在，通过FileWriter方法循环遍历稀疏数组写入数据
    FileWriter writer = new FileWriter(file);
    for(int i =0; i < sparseArr.length; i++) {
        for(int j = 0; j < 3; j++) {
            writer.write(sparseArr[i][j]);
        }
    }
    //强制要求所有缓冲的输出字节被写入，否则出现流的另一边读取不到数据的问题
    writer.flush();
    writer.close();

*读盘操作

读取磁盘中的稀疏数组文件，并还原稀疏数组。

    //通过FileReader方法读取磁盘文件
    FileReader reader = new FileReader("sparseArray.txt");
    //设置一个临时变量用于接收读出的数据
    int getNum = 0;
    int[][] sparseArr = new int[lineNums][3];
            for(int i = 0;i < lineNums;i++) {
        for (int j = 0; j < 3; j++) {
            getNum = reader.read();
            sparseArr[i][j] = getNum;
        }
    }
    //最后返回生成的稀疏数组
    return sparseArr;

稀疏数组转二维数组

读取稀疏数组第一行创建原始二维数组，并根据后几行更改二维数组对应数据。

/*
        将稀疏数组 恢复成 原始的二维数组
        1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int[11][11]
        2.再读取稀疏数组后几行的数据，并赋值给原始的二维数组即可
         */

        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

        //2.读取稀疏数组后几行的数据
        //输出恢复后的二维数组(第二行开始)，并赋值给原始的二维数组

        for (int i = 1; i < sparseArr.length; i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println();
        System.out.println("恢复后的二维数组");

        for (int[] row : chessArr2){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        for (int i = 1; i < 10; i++){
            int sum1 = 0;
            sum1+= i;
        }

二维数组打印结果：

恢复后的二维数组
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	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	0	

总结

稀疏数组是用时间换空间的一种方法，他通过对复杂数组的分析转化，获得简单有效的数据，便于计算机的运算和处理，也使得数据的有效率和利用率大大提高。稀疏数组不仅仅用于“数值为0的元素数目远远多于非0元素的数目”这种情况，只要一个二维数组中，有效值数远远小于数组元素总数，就能将稀疏数组引用进来。