一. 稀疏数组SparseArray

问题分析：

• 当我们设计一个棋盘或者地图的时候，如果使用原始二维数组存储
• 首先或出现很多默认值为0，这样二维数组的规模就会变大
• 存储了很多没有意义的0的数据
• 所以我们得到了一个解决方案：使用稀疏数组

---

稀疏数组使用

目标：将上图二维数组转换为稀疏数组

稀疏数组的特点：

• 当一个数组中大部分元素为0，或者为同一个值的数组时候，可以使用稀疏数组来保存该数组

• 稀疏数组的存储数据：

• 稀疏数组记录数组一共有有几行几列，有多少个不同的值
• 把具有不同值的元素的行列记录在一个小规模的数组中，从而缩小程序的规模
• 稀疏数组行不确定的，列有三列
• 稀疏数组第一列存储行
  • 第二列存储列
  • 第三列存储值
• 稀疏数组第一行的数据分别是：
  • [0][0]该二维数组有多少行
  • [0][1]该二维数组有多少列
  • [0][2]该二维数组有多少条数据
• 其次后面的行记录的是有值元素的行位置，列位置，以及存储元素的值

---

代码实现：将二维数组转换为稀疏数组，稀疏数组转换为二位数组

---

1、实现将二维数组转换为稀疏数组的思路

（1）初始化一个二维数组，里面存放数据

（2）遍历原始的二维数组，得到有效数据的个数sum【这个就可以或缺稀疏数组的大小】

（3）根据sum个数创建稀疏数组SparseArr 。  int[sum+1][3]，行不确定，列是确定的

（4）将二维数组的有效数据存入到稀疏数组中。

---

2、稀疏数组转换成原始二维数组思路

（1）读取稀疏数组第一行，初始化二维数组的大小

（2）在读取稀疏稀疏数组后几行，将数据赋值给原始的二维数组即可

---

代码实现

public class Test01 {
    private final static int ARR_ROW = 11;
    private final static int ARR_COL = 11;

    public static void main(String[] args) {
        // 1、初始化一个11*11的二维数组
        int[][] arrays = new int[ARR_ROW][ARR_COL];

        System.out.println("最原始的二维数组：");
        // 2、先遍历数据
        for (int[] rows : arrays) {
            for (int item : rows) {
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

        // 3.给二维数组初始化数据
        arrays[0][2] = 3;
        arrays[5][2] = 55;
        arrays[6][4] = 35;

        System.out.println("\n\n存储了数据的二维数组：");
        // 2、先遍历数据
        for (int[] rows : arrays) {
            for (int item : rows) {
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }


        // 4. 遍历二维数组获取，得到有效数据的的个数
        int sum = 0;
        for (int[] rows : arrays) {
            for (int item : rows) {
                if (item>0) sum++;
            }
        }
        System.out.println("\n\n二维数组的有效个数："+sum);

        // 5. 初始化稀疏数组  稀疏数组行等于1 + 有效个数sum，列等于3
        int[][] sparseArray = new int[sum + 1][3];
        // 5.1 初始化第一行数据  ，第一行第一个元素存储的是：二位数组多少行，第一行第二个元素存储的是：二维数组多少列，第一行第三个元素存储的是二维数组：有多少个有效个数
        sparseArray[0][0] = ARR_ROW;
        sparseArray[0][1] = ARR_COL;
        sparseArray[0][2] = sum;

        // 5.2 遍历二维数组，将有效数据的行坐标和列坐标以及·元素的值存储稀疏数组中
        System.out.println(arrays.length);
        int sparseIndex = 1;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays.length; j++) {
                if (arrays[i][j] > 0) {
                    // 第n行第一个元素存储的是：元素所在行
                    sparseArray[sparseIndex][0] = i;
                    // 第n行第二个元素存储的是：元素所在列
                    sparseArray[sparseIndex][1] = j;
                    // 第n行第三个元素存储的是二维数组：元素的值
                    sparseArray[sparseIndex][2] = arrays[i][j];
                    sparseIndex++;
                }
            }
        }

        // 6. 展示稀疏数组
        System.out.println("\n\n二维数组转换成稀疏数组：");
        for (int[] cols : sparseArray) {
            for (int item : cols) {
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

        // 7.将稀疏数组转换成二维数组
        // 7.1 创建一个新的二维数组
        int[][] newArrays = new int[sparseArray[0][0]][sparseArray[0][1]];

        // 7.2 遍历稀疏数组，初始化二维数据的值
        for (int i = 1; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray.length; j++) {
                newArrays[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
            }
        }

        System.out.println("\n\n稀疏数组转换成二维数组：");
        // 7.3 展示新的二维数组
        for (int[] cols : newArrays) {
            for (int item : cols) {
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

    }
}

结果：