【数据结构与算法(Java)】稀疏数组 Sparse Array

1. 应用场景

某个数组中大部分元素的值是0或者同一值，可以用 “稀疏数组” 来保存。
eg.
0 0 0 0 0 0 0
0 2 0 0 3 0 0
0 0 0 8 0 0 0
1 0 0 0 0 0 0
0 5 0 0 0 9 0

2. 处理思路

（1）思路

• [0] 记录 “有几行几列” ，有多少 “不同的值”
• [1]-[n] 把 “不同的值” 的 ”行”、“列”和“值” 记录在一个 “小数组” 里
  例1.
  原始二维数组
  0 0 0 0 0 0 0
  0 2 0 0 3 0 0
  0 0 0 8 0 0 0
  1 0 0 0 0 0 0
  0 5 0 0 0 9 0
  稀疏数组：

	行	列	值
[0]	5	7	6
[1]	1	1	2
[2]	1	4	3
[3]	2	3	8
[4]	3	0	1
[5]	4	1	5
[6]	4	5	9

（2）步骤

- 二维数组 -> 稀疏数组

1. 遍历 原始的二维数组，得到 有效数据的个数“sum”。
2. 根据 “sum”，创建“稀疏数组”。
3. 将二维数组的有效数据 “存入” 稀疏数组。

- 稀疏数组 -> 二维数组

1. 读取 稀疏数组的 第一行， 根据第一行的数据，创建 原始的 “二维数组”。
2. 读取 稀疏数组的 后几行，赋值 给原始的二维数组。

3. 实现（例1）

- 二维数组 -> 稀疏数组

		// 初始化二维数组【例子来自2.处理思路（1）思路】
		int[][] originalTwoDimensionalArray1 = new int[5][7];
        originalTwoDimensionalArray1[1][1] = 2;
        originalTwoDimensionalArray1[1][4] = 3;
        originalTwoDimensionalArray1[2][3] = 8;
        originalTwoDimensionalArray1[3][0] = 1;
        originalTwoDimensionalArray1[4][1] = 5;
        originalTwoDimensionalArray1[4][5] = 9;
		// 1. 遍历 原始的二维数组，得到 有效数据的个数“sum”。
        int sum = 0;
        for (int[] row : originalArray1){
            for (int data : row){
                if (data != 0){
                    sum += 1;
                }
            }
        }

        // 2. 根据 “sum”，创建“稀疏数组”。
        int[][] sparseArray1 = new int[sum + 1][3];
        sparseArray1[0][0] = originalArray1.length;
        sparseArray1[0][1] = originalArray1[0].length;
        sparseArray1[0][2] = sum;

        // 3. 将二维数组的有效数据 “存入” 稀疏数组。
        int count = 0;
        for (int rowNo = 0; rowNo < originalArray1.length; rowNo++){
            for (int itemNo = 0; itemNo < originalArray1[0].length; itemNo++){
                if (originalArray1[rowNo][itemNo] != 0){
                    count++;
                    sparseArray1[count][0] = rowNo;
                    sparseArray1[count][1] = itemNo;
                    sparseArray1[count][2] = originalArray1[rowNo][itemNo];
                }
            }
        }

- 稀疏数组 -> 二维数组

		// 初始化稀疏数组
		int[][] originalSparseArray1 = new int[7][3];
        originalSparseArray1[0][0] = 5;
        originalSparseArray1[0][1] = 7;
        originalSparseArray1[0][2] = 6;
        originalSparseArray1[1][0] = 1;
        originalSparseArray1[1][1] = 1;
        originalSparseArray1[1][2] = 2;
        originalSparseArray1[2][0] = 1;
        originalSparseArray1[2][1] = 4;
        originalSparseArray1[2][2] = 3;
        originalSparseArray1[3][0] = 2;
        originalSparseArray1[3][1] = 3;
        originalSparseArray1[3][2] = 8;
        originalSparseArray1[4][0] = 3;
        originalSparseArray1[4][1] = 0;
        originalSparseArray1[4][2] = 1;
        originalSparseArray1[5][0] = 4;
        originalSparseArray1[5][1] = 1;
        originalSparseArray1[5][2] = 5;
        originalSparseArray1[6][0] = 4;
        originalSparseArray1[6][1] = 5;
        originalSparseArray1[6][2] = 9;
        
		// 1. 读取 稀疏数组的 第一行， 根据第一行的数据，创建 原始的 “二维数组”
        int[][] twoDimensionalArray = new int[originalSparseArray1[0][0]][originalSparseArray1[0][1]];

        // 2. 读取 稀疏数组的 后几行，赋值 给原始的二维数组。
        for (int rowNo = 1; rowNo < originalSparseArray1.length; rowNo++){
            twoDimensionalArray[originalSparseArray1[rowNo][0]][originalSparseArray1[rowNo][1]] = originalSparseArray1[rowNo][2];
        }