数据结构——二维数组与稀疏数组的互相转换

package com.sjjg.sparsearray;

//二维数组 转 稀疏数组的思路
//        1. 遍历 原始的二维数组，得到有效数据的个数 sum
//        2. 根据sum 就可以创建 稀疏数组 sparseArr   int[sum + 1] [3]
//        3. 将二维数组的有效数据数据存入到 稀疏数组
//
//        稀疏数组转原始的二维数组的思路
//
//        1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  arr2 = int [8][8]
//        2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组 即可.

public class T3 {

    public static void main(String[] args) {
        //创建一个8*8的二维数组棋盘
        int[][] arr = new int[8][8];

        //0	0	0	0	0	0	0	0
        //0	0	1	0	0	0	0	0
        //0	0	0	2	0	0	0	0
        //0	0	0	0	1	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代表白棋子  2代表黑棋子
        arr[1][2]=1;
        arr[2][3]=2;
        arr[3][4]=1;

        //增强for循环 遍历输出此二维数组棋盘当前布局
        System.out.println("当前布局:");
        for (int[] row : arr){
            for (int date : row){
                System.out.printf("%d\t",date);
            }
            System.out.println();
        }

        //用sum变量来记录非0数值 在这也就是棋子数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(arr[i][j] != 0){
                    sum++;
                }
            }
        }

        //创建一个稀疏数组
        //sum+1 是因为稀疏数组需要多一行头行来记录行 列 非0数值个数
        //3 是因为稀疏数组只有3列
        int[][] sparseArr = new int[sum+1][3];

        //给头行赋值
        sparseArr[0][0]=8;
        sparseArr[0][1]=8;
        sparseArr[0][2]=sum;

        //给剩下的赋值
        int count=0; //记录行数 因为稀疏数组的头行也就是第0行 是用于记录要被转换的二维数组的 行 列 非0个数
                     //所以当出现非0数时 我们就让其count++ 用它来充当稀疏数组的行变量
                     //一定要用count充当稀疏数组的行变量 如果用循环中的i变量直接作稀疏数组的行变量
                     //此时如果二维数组的第0列有非0数的话 转换出来的稀疏数组头行 也就是记录被转换的二维数组的 行 列 非0个数 会出错
                     //具体可以调试
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i][j] != 0){
                    count++;//用它充当稀疏数组的行数 当出现非0数时 count就会+1 就会自己在下一行操作 不会与头行冲突 不会与上一次记录的冲突
                    //因为稀疏数组只有3列 所以第二个【】里的索引范围只在0 1 2
                    //在二维数组arr[i][j] != 0时 arr[i][j]这个数值 就是在arr二维数组的第i行第j列
                    sparseArr[count][0]=i; //sparseArr[count][0]是用于记录行位置 所以就把i行赋值给sparseArr[count][0]
                    sparseArr[count][1]=j; //sparseArr[count][1]是用于记录列位置 所以就把j列赋值给sparseArr[count][1]
                    sparseArr[count][2]=arr[i][j]; //sparseArr[count][2]是用于记录非0的数值 所以就把arr[i][j]当前非0的数赋值给sparseArr[count][2]


                    /* //不可直接用i变量来充当稀疏数组的行数
                    sparseArr[i][0]=i; //sparseArr[i][0]是用于记录行位置 所以就把i行赋值给sparseArr[i][0]
                    sparseArr[i][1]=j; //sparseArr[i][1]是用于记录列位置 所以就把j列赋值给sparseArr[i][1]
                    sparseArr[i][2]=arr[i][j]; //sparseArr[i][2]是用于记录非0的数值 所以就把arr[i][j]当前非0的数赋值给sparseArr[i][2]
                    */
                }
            }
        }

        System.out.println();
        System.out.println("稀疏数组：");
        //for循环输出稀疏数组
        //因为稀疏数组只有3列 所以第二个【】里固定为 0 1 2 就可以直接一层for循环遍历
        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();
        System.out.println("------------稀疏数组转二维数组----------------------------------");

        //创建一个新二维数组8*8棋盘表
        int[][] arr2 = new int[8][8];

        //for循环遍历稀疏数组sparseArr 给 新二维数组arr2 赋值
        //因为稀疏数组只有3列 所以第二个【】里固定为 0 1 2 就可以直接一层for循环遍历
        //i=1 是因为稀疏数值头行也就是第0行是记录二维数组的 总行数 总列数 总非0数个数 所以i直接1从开始
        for (int i = 1; i < sparseArr.length; i++) {
            //sparseArr[i][0] 记录在二维数组里的行数
            //sparseArr[i][1] 记录在二维数组里的列数
            //sparseArr[i][2] 在此行此列的那个数的数值
            arr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];

        }

        //增强for循环遍历新二维数组arr2
        for (int[] row : arr2){
            for (int date : row){
                System.out.printf("%d\t",date);
            }
            System.out.println();
        }

    }
}