二、稀疏数组

1、稀疏数组（spareseArray）

　　先看一个实际需求，编写一个五子棋程序，有存盘和续上盘的功能。

分析问题：

因为改二维数组的很多默认值是0，因此记录了很多没有意义的数据-->稀疏数组

1.1、基本介绍

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

　稀疏数组的处理方法是：

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

1.2、应用实例

使用稀疏数组，来保留类似前面的二维数组（棋盘、地图）
把稀疏数组存盘，并且可以重新恢复原来的二维数组
整体思路

上图原始二维数组和稀疏数组的关系解释
- 原始二维数组是11*11的有两个值1 、2
- 稀疏数组也是一个二维数组，n行3列，第一列表示行号，第二列表示列号，第三列表示行列对应原始二维数组上的值。
- 稀疏数组第一行表示原始二维数组的信息，如上图表示原始二维数组有11行11列原始二维数组有两个有用值
- 稀疏数组其他行表示原始数组中有用值的坐标和值

1.2.1、二维数组转稀疏数组的思路

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

1.2.2、稀疏数组转原始的二维数组的思路

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

1.2.3、代码实现

package com.com.jdy;

public class SparseArray {

    public static void main(String[] args) {
        int[][] originArr = createOriginArr();

        int[][] sparseArrays = originToSparse(originArr);
        sparseToOrigin(sparseArrays);

    }

    /**
     * 稀疏数组转原始的二维数组的思路
     * step1：先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
     * step2: 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
     * @param sparseArr
     */
    public static void sparseToOrigin(int[][]  sparseArr){
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];

        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        System.out.println("恢复后的稀疏数组~~~~~~");

        for (int[] rows : chessArr2) {
            for (int data : rows) {
                System.out.printf("%d	",data);
            }
            System.out.println();
        }
    }

    /**
     *二维数组转稀疏数组
     * 　1. 遍历原始的二维数组，得到有效数据的个数 sum
     * 　2. 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]
     * 　3. 将二维数组的有效数据数据存入到 稀疏数组
     */
    public static int [][] originToSparse(int[][] chessArr){
        //step1：遍历原始的二维数组，得到有效数据的个数
        int sum =0;
        for (int[] rows : chessArr) {
            for (int data : rows) {
                if(data!=0){
                    sum++;
                }
            }
        }
        //step2：根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]
        int[][] sparseArrays = new int[sum + 1][3];
        //step3：将二维数组的有效数据数据存入到稀疏数组
        sparseArrays[0][0]=11;
        sparseArrays[0][1]=11;
        sparseArrays[0][2]=sum;

        int count =0;

        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(chessArr[i][j]!=0){
                    count++;
                    sparseArrays[count][0]=i;
                    sparseArrays[count][1]=j;
                    sparseArrays[count][2]=chessArr[i][j];
                }
            }
        }

        System.out.println("得到的稀疏数组为~~~~~~~~~~");
        for (int i = 0; i < sparseArrays.length; i++) {
            System.out.printf("%d	%d	%d	
",sparseArrays[i][0],sparseArrays[i][1],sparseArrays[i][2]);
        }

        return sparseArrays;
    }


    public static int [][] createOriginArr(){
        //创建一个二维数组11*11
        //0：表示没有棋子，1表示黑子，2表示蓝子
        int chessArr[][] = new int[11][11];
        chessArr[1][2]=1;
        chessArr[2][3]=2;
        chessArr[4][5]=2;

        //输出原始的二维数组
        System.out.println("原始的二维数组");
        for (int[] rows : chessArr) {
            for (int data : rows) {
                System.out.printf("%d	",data);
            }
            System.out.println();
        }

        return chessArr;
    }
}