1.稀疏数组（sparseArray）----五子棋盘的保存与还原

1.稀疏数组（sparseArray）----五子棋盘的保存与还原

（1）实例：五子棋的存储与复盘。

（2）基本介绍：

• 当一个数组中绝大部分元素为0，或者大多数元素相同的时候，可以使用稀疏数组来保存这样的数组。
• 稀疏数组的处理方法是：
  • 记录原二维数组中有多少个行列，以及多少个不为0的元素sum.
  • 把具有不同元素值的行列以及值记录在一个较小规模的二维数组中，从而缩小程序的规模。
  • 在小规模的数组中，第一行存储原始二维数组的行列以及值（行列值都是下标），第二行开始存储不同元素的行列值。

（2）二维数组转化为稀疏数组的思路：

• 遍历循环原二维数组，用sum记录原二维数组中的不同元素的个数。

• 创建一个新的稀疏数组，数组的行为sum+1，即原二维数组中的不同元素的个数，数组的列为3.如下：

  int arr1[][]=new int[sum+1][3]
  并且赋值第一行元素。
  

• 遍历循环原二维数组，将不为0 的二维数组的行列值赋值给稀疏数组，将值存储在这个数组中。遍历循环出稀疏数组。

（3）稀疏数组转化为二维数组的思路：

• 获取稀疏数组第一行的行列值，创建原二维数组。
• 遍历稀疏数组的后几行，将稀疏数组的具体的值赋值给二维数组的行列，
• 遍历循环二维数组，输出原二维数组

具体代码如下：（自己默写并执行成功的代码）

package com.chanchan.sparseArray;
public class SparseArray02 {
    public static void main(String[] args) {
        //创建一个二维数组
        System.out.println("原二维数组如下：");
        int arr1[][] =new int[11][11];
        arr1[1][2]=1;
        arr1[2][3]=2;
        arr1[5][6]=2;
        //遍历二维数组
        int sum=0;
        for (int[] row:arr1){
            for(int data:row){
                System.out.printf("%d\t",data);
                if (data!=0)
                    sum++;
            }
            System.out.println();
        }
        System.out.println("sum="+sum);
        //遍历二维数组，将二维数组的不同元素的个数计算出来,
        //创建一个稀疏数组，数组的列为sum+1
        int[][] arr2=new int[sum+1][3];
        arr2[0][0]=11;
        arr2[0][1]=11;
        arr2[0][2]=sum;

        //遍历二维数组，将二维数组中不为0的元素赋值给稀疏数组
        int count=1;
        for (int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(arr1[i][j]!=0) {
                    arr2[count][0] = i;
                    arr2[count][1] = j;
                    arr2[count][2] = arr1[i][j];
                    count++;
                }
            }
        }
        System.out.println("二维数组给稀疏数组赋值完毕");
        System.out.println();
        //遍历稀疏数组
        System.out.println("二维数组转换后的稀疏数组如下：");
        for (int[] row:arr2){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //将稀疏数组还原为稀疏数组
        //首先将稀疏数组中的元素值赋值给二维数组。
        int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
        for(int i=1;i<arr2.length;i++){
            arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
        }
        System.out.println("二维数组还原成功");
        //遍历二维数组
        for (int[] row:arr3){
            for (int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

    }
}

视频代码：

package com.chanchan.sparseArray;
public class SparseArray {
    public static void main(String[] args) {
        //定义一个原始的二维数组,并给这个数据元素赋值
        int[][] arr=new int[11][11];
        arr[1][2]=1;          //1代表白子，2代表黑子
        arr[2][3]=2;
        arr[5][6]=2;
        for(int[] row:arr) {  //输出原始和二维数组
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //读取二维数组的行列，以及二维数组中不为0的数，记录不为0的数字的个数
        int sum=0;
        for(int[] row:arr){
            for (int data:row){
                if(data!=0)
                    sum++;
            }
        }
        System.out.println("sun="+sum);

        //将原二维数组转化为稀疏矩阵：行，列，值。
        int[][] arr2=new int[sum+1][3];  //定义一个稀疏数组，将第一行给。
        arr2[0][0]=11;
        arr2[0][1]=11;
        arr2[0][2]=sum;

        //遍历二维数组中的元素，将不为o的数赋值给稀疏数组
        int count=1;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(arr[i][j]!=0){
                    arr2[count][0]=i;
                    arr2[count][1]=j;
                    arr2[count][2]=arr[i][j];
                    count++;
                }
            }
        }
        System.out.println();
        System.out.println("得到稀疏矩阵");
        for(int[] x:arr2){
            for (int y:x){
                System.out.print("\t");
                System.out.print(y);
            }
            System.out.println();
        }
        //将稀疏数组转化为二维数组。
        //定义一个二维数组，二维数组的大小为读取的稀疏数组的第一行的值。
        int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
        //读取稀疏数组的后几行值,并赋值给原始二维数组。
        for(int i=1;i<arr2.length;i++){
            arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
        }
        System.out.println();
        System.out.println("恢复后的二维数组");
        for (int[] row:arr3){  //遍历恢复后的二维数组
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}