稀疏数组
稀疏数组简介：
- 当一个数组中大部分数据均为0（均为同一个数值） 时，可以用稀疏数组来保存该数组
- 压缩存储（保留有效数据） 可以节省存储空间以避免资源的不必要的浪费
存储方式（非链式存储）：
| 0 |
1 |
2 |
| 原始数组行数 |
原始数组列数 |
有效数据个数 |
| 有效数据所在行 |
有效数据所在列 |
有效数据 |
| – |
– |
– |
- 第一行存储原始数据总行数，总列数，总的有效数据个数
- 接下来每一行都存储有效数据所在行，所在列和具体值
|
0 |
1 |
2 |
3 |
4 |
| 0 |
0 |
1 |
0 |
2 |
0 |
| 1 |
0 |
0 |
0 |
2 |
0 |
| 2 |
1 |
1 |
0 |
0 |
0 |
| 3 |
0 |
0 |
0 |
2 |
0 |
稀疏数组：
|
0 （行数） |
1 （列数） |
2 （有效数据） |
| 0 |
5 (总行数) |
4 (总列数) |
6 (有效数据个数) |
| 1 |
0 |
1 |
1 |
| 2 |
0 |
3 |
2 |
| 3 |
1 |
3 |
2 |
| 4 |
1 |
0 |
1 |
| 5 |
1 |
1 |
1 |
| 6 |
2 |
4 |
2 |
代码实现：
- 得到原始数组的行列数
- 遍历原始数组得到有效数据个数
- 创建稀疏数组并对稀疏数组进行赋值
（1）对稀疏数组第一行进行赋值（原始数组的总行数，总列数，总的有效数据个数）
（2）遍历原始数组将有效数据及其对应位置放入稀疏数组
public static int[][] toSparseArray(int[][] array, int invalid) {
int sum = 1, row = array.length, col = array[0].length;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (array[i][j] != invalid)
sum++;
}
}
int[][] sparseArr = new int[sum][3];
sparseArr[0][0] = row;
sparseArr[0][1] = col;
sparseArr[0][2] = sum - 1;
int count = 0;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (array[i][j] != invalid) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = array[i][j];
}
}
}
return sparseArr;
}
- 根据稀疏数组的第一行创建原始数组
- 将稀疏数组中的数据还原到原始数组
public static int[][] toArray(int[][] sparseArr) {
int[][] array = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i <= sparseArr[0][2]; i++) {
array[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
return array;
}
完整程序测试：
- 测试数据
原始矩阵：
00000000000
00000100000
00000010000
00000020000
00000000000
00000000100
00000000001
00000000000
00000000000
00002000000
00000200000
- 结果预测
11 11 7
1 5 1
2 6 1
3 6 2
5 8 1
6 10 1
9 4 2
10 5 2
- 程序代码
package DataStructures.linear.sparseArray;
public class SparseArray {
public SparseArray() {
}
public static int[][] toSparseArray(int[][] array) {
return toSparseArray(array, 0);
}
public static int[][] toSparseArray(int[][] array, int invalid) {
int sum = 1, row = array.length, col = array[0].length;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (array[i][j] != invalid)
sum++;
}
}
int[][] sparseArr = new int[sum][3];
sparseArr[0][0] = row;
sparseArr[0][1] = col;
sparseArr[0][2] = sum - 1;
int count = 0;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (array[i][j] != invalid) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = array[i][j];
}
}
}
return sparseArr;
}
public static int[][] toArray(int[][] sparseArr) {
int[][] array = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i <= sparseArr[0][2]; i++) {
array[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
return array;
}
private static boolean equal(int[][] array, int[][] sparseArr) {
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (array[i][j] != sparseArr[i][j])
return false;
}
}
return true;
}
public static void main(String[] args) {
int[][] a = new int[11][11];
a[1][5] = 1;
a[3][6] = 2;
a[2][6] = 1;
a[6][10] = 1;
a[10][5] = 2;
a[5][8] = 1;
a[9][4] = 2;
System.out.println("原始数组：");
for (int[] is : a) {
for (int n : is)
System.out.print(n);
System.out.println();
}
System.out.println("-----------------------------");
int[][] s = toSparseArray(a);
System.out.println("稀疏数组：");
for (var is : s) {
for (var n : is)
System.out.print(n + " ");
System.out.println();
}
System.out.println("-----------------------------");
int[][] b = toArray(s);
System.out.println("还原后的数组：");
for (var is : b) {
for (var n : is)
System.out.print(n);
System.out.println();
}
System.out.println("-----------------------------");
System.out.println((equal(a, b)) ? "两数组相同" : "两数组不相同");
}
}
- 运行结果
