稀疏数组和二维数组

二维数组可以存储很多东西，比如，围棋，五子棋，整个棋盘就是可以看作一个巨大的二维数组，里面黑棋白棋在数组中可以用数字1或者2表示，空白的地方，一般用0表示。但是由于棋盘很大，所以对应的二维数组也是很大，如果就这样存储的话，二维数组存储了很多数据，但是这些数据又存储了大量重复的东西，所以是一种浪费，对程序来说，也是一种拉低效率的。同理地图也是这样的。

我们说过，程序是为了更简便的解决生活中的问题，快速高效的解决问题.

举个栗子，比如现在有如下的一个二维数组

这是一个名为Arr1的10*10的数组，其中只有Arr1[0][4]=1,Arr1[1][2]=1,其余的空间的值都为0.

也就是说，这个数组占据着很大一个空间，但是大部分的空间都是些无用的数。

所以，为了压缩数组，让性能有所提升，稀疏数组的出现，便让问题得到了解决。

稀疏数组是一个是一个固定的样子，row,col,value,它的列坐标是固定的，第一行存储着原始二维数组的行，列，以及有效的个数。第二行才开始存储每个坐标的位置和值。所以稀疏数组为spareArr int[sum+1][3],其中sum是有效数加1.

二维数组变稀疏数组

1.遍历二维数组，得到其中有效的个数sum

2.然后创建稀疏数组spareArr int[sum+1][3]

3.将二维数组的有效数存储到稀疏数组中

稀疏数组变二维数组

1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组

2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组 

代码如下：

public class SparseArr {
    public static void main(String[] args) {
        //原始数组
        int Arr1[][]=new int[10][10];
        Arr1[0][4]=1;
        Arr1[1][2]=1;
        System.out.println("原始的二维数组~~");
        //输出原始数组
//        for ( 变量类型  变量名 : 数组名 ) {
//            需要执行的循环语句;
//        }
//        for(int[] row:Arr1){
//            for(int:Arr1){
//        }
//        for (int[] row : Arr1) {
//            for (int data : row) {
//                System.out.printf("%d\t", data);
//            }
//            System.out.println();
//        }
        //%d输出整型，%f输出浮点型，%n是转行的意思
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++)
            {
                System.out.printf("%d\t",Arr1[i][j]);
            }
            System.out.println();
        }

        // 1.将二维数组 转 稀疏数组的
        int sum=0;//计数二维数组的有效数字
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++)
            {
                if(Arr1[i][j] !=0){
                    sum++;
                }
            }
        }
        //2.创建稀疏数组
        int sparseArr [][]=new int[sum+1][3];
        sparseArr [0][0]=10;
        sparseArr [0][1]=10;
        sparseArr [0][2]=sum;
        // 遍历二维数组，将非0的值存放到 sparseArr中
        int count=0;
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++)
            {
                if(Arr1[i][j] !=0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = Arr1[i][j];
                }
            }
        }

        // 输出稀疏数组
//        int a[2][2];
//        int len1=a.length;     //表示一共有多少行（列长度）
//        int len2=a[i].length.    //表示一共有多少列（行长度）
        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 Arr2[][]=new int[sparseArr [0][0]][ sparseArr [0][1]];
        //从稀疏数组的第二行开始遍历
        for (int i=1;i<sparseArr.length;i++){
            Arr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr [i][2];
        }
        //打印Arr2[][]
//        for (int i = 0; i < sparseArr [0][0]; i++) {
//            for (int j = 0; j < sparseArr [0][0]; j++) {
//                System.out.printf("%d",Arr2[i][j]);
//            }
//            System.out.println();
//        }
        for (int[] number:Arr2
             ) {
            for(int data:number){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}