稀疏数组和目标存储数组的相互转化的算法

代码如下，具体见代码注释：

public class Aa {
    public static void main(String[] args) {
        //创建一个二维数组11*11 0：没有棋子  1：黑棋  2：白棋
        int[][] aa=new int[11][11];
        aa[1][2]=99;
        aa[2][3]=521;
        //输出数组
        System.out.println("输出数组：");

        /*
            第一层遍历的时候因为二维数组中的每一个元素都是一个数组，所以遍历应将每个元素(数组)遍历到
            一个新的数组中
         */
        for(int[] b : aa){
            /*
                第二层遍历由于第一层遍历完成后，每个元素都是一个一维数组，则只需要使用一个变量来遍历
                数组中的每个元素，然后进行输出即可
             */
            for (int c : b){
                System.out.print(c+"  ");//这里使用print是为了不换行
            }
            System.out.println();   //这里使用printlin是为了换行
        }


        System.out.println("---------------------------------------------");
        //转换为稀疏数组来保存

        //1.获取有效值的个数
        int sum=0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if(aa[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效数值的个数"+sum);

        //2.创建一个稀疏数组的数组
        int[][] bb=new int[sum+1][3];  //这里有效数字的个数+1就是稀疏数组的行数
        //这里是稀疏数字的第一列
        bb[0][0]=11;
        bb[0][1]=11;
        bb[0][2]=sum;

        //遍历二维数组，将非零的值，存储在稀疏数组中
        int cout=0;

        /*
            这里是遍历一开始建立的数组，这里的cout是稀疏数组的行数，在循环中每当遇到一个非零的数，
            这个数就是一个有效数字，此时cout++，第一个数就放在了稀疏数组的第一行(第0行存储的是稀疏
            数组所存储的目标数组是几行几列，以及有效数字的个数)，同时将此时这个数的行数赋值给稀疏
            数组的此行的第0列，列数赋值给第1列，目标数组中的数字为第二列
         */
        for (int i=0;i<aa.length;i++){
            //这里j小于的是二维数组中每个元素(数组)的长度
            for (int j=0;j<aa[i].length;j++){
                if(aa[i][j]!=0){
                    cout++;
                    bb[cout][0]=i; // 第cout行第0列，存储行数
                    bb[cout][1]=j; // 第cout行第1列，存储列数
                    bb[cout][2]=aa[i][j]; // 第cout行第2列，存储数值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组:");

        for(int i=0;i< bb.length;i++){
            System.out.println("["+bb[i][2]+"]"+"\t"+bb[i][0]+"\t"+bb[i][1]+"\t"+bb[i][2]+"\t");
        }

        System.out.println("==========================");

        // 从稀疏数组中进行还原，还原目标数组
        System.out.println("还原：");

        //读取稀疏数组的值
        /*
            稀疏数组的第0行第0列存储目标数组的行数
            第0行第1列存储目标数组的列数
         */
        int[][] cc=new int[bb[0][0]][bb[0][1]];

        //给其中的元素还原它的值

        /*
            这里为什么i从1开始，是因为稀疏数组的第0行是存储目标数组的行列等信息，从第1行开始才
            存储了目标数组中有效数字的坐标以及具体的数值
         */
        for (int i=1;i<bb.length;i++){
            /*
                由于使用new进行数组初始化时，默认数组中的每个元素将会被赋值为0，恰好目标数组的
                非有效数字也是0，则这里进行的还原是将有效数字进行还原，其他的0不需要处理
             */
            cc[bb[i][0]][bb[i][1]]=bb[i][2];
        }

        //打印稀疏数组
        System.out.println("输出还原的数组:");

        for(int[] b : aa){
            for (int c : b){
                System.out.print(c+"  ");//这里使用print是为了不换行
            }
            System.out.println();   //这里使用printlin是为了换行
        }

    }
}