Java数组07：稀疏数组

     本节内容视频链接：   https://www.bilibili.com/video/BV12J41137hu?p=59&vd_source=b5775c3a4ea16a5306db9c7c1c1486b5https://www.bilibili.com/video/BV12J41137hu?p=59&vd_source=b5775c3a4ea16a5306db9c7c1c1486b5        稀疏数组（‌sparse array）‌在Java中是一种针对大部分元素为默认值或特定值的数组进行优化的存储结构‌。‌

        其基本思想是只存储非默认值的元素及其对应的位置信息，‌以减少内存的使用。‌

        稀疏数组通常由三列组成：‌行数、‌列数和值。‌

        其中，‌第一列表示非默认值（非0）的行号，‌第二列表示非默认值（非0）的列号，‌第三列表示对应的值。‌如下图：

        通过这种方式，‌可以用较小的存储空间来表示具有大量默认值的数组，‌从而提高存储效率。‌

        稀疏数组特别适用于处理像棋盘、‌地图这样大部分元素为0或同一值的二维数组，‌通过稀疏数组可以有效减少存储空间的浪费。‌‌

1.创建一个需要压缩的二维数组，并打印出来。

package array;

public class ArrayDemo06 {
    //创建一个11行、11列的二维数组   0:表示没有棋子；1：表示黑棋；2：表示白棋
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+ "\t");
            }
            System.out.println();
        }

2.把创建的二维数组压缩成稀疏数组，并打印出来

package array;

public class ArrayDemo06 {
    //创建一个11行、11列的二维数组   0:表示没有棋子；1：表示黑棋；2：表示白棋
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+ "\t");
            }
            System.out.println();
        }
        System.out.println("======================================");
        //以下代码展示如何把普通二维数组压缩成为稀疏数组
        //第1步：获取原数组中有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("数组中有效值的个数为：" + sum);

        //第2步、创建一个新的稀疏数组，行是原数组有效值+1，列固定为3
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = array1.length;  //第0行第0列的值为原数组的行数
        array2[0][1] = array1[0].length;//第0行第1列的值为原数组的列数
        array2[0][2] = sum;//第0行第2列的值为原数组中有效值的个数

        //第3步、遍历二维数组，将非0的值，存储在稀疏数组中
        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){//当判断原数组第i行第j列不等于0时，给新建稀疏数组赋值
                    count++;
                    array2[count][0] = i;  //新建稀疏数组的第count行第0列值为i
                    array2[count][1] = j;  //新建稀疏数组的第count行第1列值为j
                    array2[count][2] = array1[i][j];//新建稀疏数组的第count行第2列值为array1[i][j]（原数组的当前值）
                }
            }
        }
        //第4步、输出稀疏数组
        System.out.println("输出稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j] + "\t");
            }
            System.out.println();
        }

3.把稀疏数组重新还原，并输出。

package array;

public class ArrayDemo06 {
    //创建一个11行、11列的二维数组   0:表示没有棋子；1：表示黑棋；2：表示白棋
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+ "\t");
            }
            System.out.println();
        }
        System.out.println("======================================");
        //以下代码展示如何把普通二维数组压缩成为稀疏数组
        //第1步：获取原数组中有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("数组中有效值的个数为：" + sum);

        //第2步、创建一个新的稀疏数组，行是原数组有效值+1，列固定为3
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = array1.length;  //第0行第0列的值为原数组的行数
        array2[0][1] = array1[0].length;//第0行第1列的值为原数组的列数
        array2[0][2] = sum;//第0行第2列的值为原数组中有效值的个数

        //第3步、遍历二维数组，将非0的值，存储在稀疏数组中
        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){//当判断原数组第i行第j列不等于0时，给新建稀疏数组赋值
                    count++;
                    array2[count][0] = i;  //新建稀疏数组的第count行第0列值为i
                    array2[count][1] = j;  //新建稀疏数组的第count行第1列值为j
                    array2[count][2] = array1[i][j];//新建稀疏数组的第count行第2列值为array1[i][j]（原数组的当前值）
                }
            }
        }
        //第4步、输出稀疏数组
        System.out.println("输出稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j] + "\t");
            }
            System.out.println();
        }

        System.out.println("还原稀疏数组");

        //第1步、新建一个数组，读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]]; //新建二维数组的行数和列数分别对应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]; //从第1行开始循环（i不能从等于0开始），把有效值还原
        }
        //第3步、打印还原后的数组
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[i].length; j++) {
                System.out.print(array3[i][j] + "\t");
            }
            System.out.println();
        }

    }
}

4.运行结果