稀疏数组的遍历

稀疏数组：1.先遍历出原始的数组（定义数组，给其中赋有效值）

2.转换为稀疏数组，获取有效值个数（算出有效值个数）

3.创建一个稀疏数组（定义数组，将稀疏数组的输出排序中第一行赋值，再计算有效值的位置且给它赋上行列值三个值）

4.输出稀疏数组

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

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数" + sum);
        System.out.println("++++++++++++++++++++++++++++");
        //2.创建一个稀疏数组的数组
        //这里的sum+1是因为稀疏数组从0开始排，有效值加+为了能把有有效值的行列知很好的展现出来
        /**
         * 排序      行    列    值
         * [0]      11    11    2
         * [1]      1     2     1
         * [2]      2     3     2
         * 这里的排序是稀疏数组最后输出的排序  不是行列的排序
         * 这里虽然有11行  但是也就只是相当于数组长度一样，下标依然从0开始数
         * 有效值的位置查询从稀疏数组最后输出的排序第二行开始算起才开始查，第一行是总的棋盘行，列，值
         */
        int[][] array2 = new int[sum + 1][3];
        /**
         * 这里的3表示的是（行、列、值、）数组长度，“记住所有数组的下标都是从0开始”
         * 第一个0表示稀疏数组输出后的第一个行，也就是输出后第一行的总的棋盘行，列，值。
         */
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;//给第一行总的棋盘范围赋值
        //遍历二维数组，将非零的值，存放稀疏数组中
        //知道有几排输出之后给每一排对应的含义
        //给有效值排序赋值
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;//count代表最后输出的有效值的排列顺序，从1开始逐渐增加
                    array2[count][0] = i;  //有效值的位置的行是i表示
                    array2[count][1] = j;//有效值的位置的列是j表示
                    array2[count][2] = array1[i][j]; //最后精确的有效值的值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }
        System.out.println("====================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }
        //3.打印
        System.out.println("输出还原的数组");

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
    /**
     * 稀疏数组：1.先给棋盘赋值，输出原始数组
     *         2.计算有效值的个数，给数组行，列，值赋值
     *         3.通过它对有效值的识别，从1开始将识别到的有效值的排序逐渐增加
     *         4.将i作为行坐标。j作为纵坐标，ij确定有效值的准确值
     *         遍历数组
     *        还原数组：重新定义数组
     *        将稀疏数组整理出来的数据交给还原数组，让它进行寻找行列数并且把值赋进去
     *
     */