一,稀疏数组
1,简介:
稀疏数组:是以某个重复出现的二维数组的值为基准,进行隐藏式压缩成n行(n=原二维数组中不同值得个数) x 3列的二维数组;
如下图:二维数组 转 稀疏数组
2,分析:
列数 == 3;
行数 = 二维数组中有效数字(如上图:除0之外的数)之外的总个数(如上图:为22,15,11…91,28的总个数=8);
所以形成的稀疏数组为3*8=24的新二维数组;
原二维数组:6*7=42,可见空间上有了一定的减少;
第0行:稀疏数组的【0】
row(行):记录的原二维数组的行数=6行;
col(列):记录的原二维数组的列数=7列;
val(值):记录的原二维数组的有效数字的总个数(如上图:为22,15,11…91,28的总个数=8),也定义了除【0】行之外的其余行的数量(为8行);
第1行:稀疏数组的【1】
row(行):记录的原二维数组的第一个有效数字的行位置(按照下标方式,从0开始,图示第一个其他数为22,在原二维数组第0行);
col(列):记录的原二维数组的第一个有效数字的列位置(按照下标方式,从0开始,图示第一个其他数为22,在原二维数组第3列);
val(值):记录的原二维数组的第一个有效数字的值22(图示第一个其他数为22);
综上:第一个有效数字的行信息为:【1】0 3 22
其他7行以此类推,得到稀疏数组
3,二维数组 转 稀疏数组
- 遍历原二维数组得到有效数字的个数sum(上图sum=8);
- 创建稀疏数组sparseArr,如int[sum+1] [[3]]的二维数组;
- 将二维数组的有效数字按照上面方式存入稀疏数组,达到减少空间效果;
4,稀疏数组 还原 二维数组
- 先读取稀疏数组第一行数据,根据行和列创建二维数组,如int[6][7];
- 再读取其余行数据根据下标放入对应的二维数组中去,达到还原效果;
对于此类数组存盘操作情况下可以很好的做的高效和压缩。
5,示例代码:
package com.data;
/**
* @param
* @Author: AaNeei
* @Date: 2019/6/11 23:00
* @Description: 游学网
* @throws:
*/
public class SparseArr {
public static void main(String[] args) {
//二维数组初始化
int[][] doubleDimensionalArray = initDoubleDimensionalArray(6, 7);
System.out.println("====================二维数组转稀疏数组============================");
//转稀疏数组
int[][] sparseArr = doubleDimensionalArrayToSparseArr(doubleDimensionalArray);
System.out.println("====================稀疏数组还原二维数组============================");
//稀疏数组还原二维数组
int[][] dimensionalArray = sparseArrRestoreDoubleDimensionalArray(sparseArr);
}
private static int[][] sparseArrRestoreDoubleDimensionalArray(int[][] sparseArr) {
int[][] doubleDimensionalArray=new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i < sparseArr.length; i++) {
doubleDimensionalArray[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
}
for (int[] ints : doubleDimensionalArray) {
for (int data : ints) {
System.out.printf("%d\t", data);
}
System.out.println();
}
return doubleDimensionalArray;
}
private static int[][] doubleDimensionalArrayToSparseArr(int[][] doubleDimensionalArray) {
int sum = 0;
for (int[] ints : doubleDimensionalArray) {
for (int anInt : ints) {
if (anInt != 0) {
sum++;
}
}
}
int[][] sparseArr = new int[sum + 1][3];
sparseArr[0][0] = doubleDimensionalArray.length;
sparseArr[0][1] = doubleDimensionalArray[0].length;
sparseArr[0][2] = sum;
//将非0的值存入稀疏数组
int count = 0;
for (int i = 0; i < doubleDimensionalArray.length; i++) {
for (int j = 0; j < doubleDimensionalArray[0].length; j++) {
if (doubleDimensionalArray[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = doubleDimensionalArray[i][j];
}
}
}
//打印稀疏数组
for (int[] ints : sparseArr) {
for (int data : ints) {
System.out.printf("%d\t", data);
}
System.out.println();
}
return sparseArr;
}
private static int[][] initDoubleDimensionalArray(int row, int col) {
int[][] doubleDimensionalArray = new int[row][col];
doubleDimensionalArray[0][3] = 22;
doubleDimensionalArray[0][6] = 15;
doubleDimensionalArray[1][1] = 11;
doubleDimensionalArray[1][5] = 17;
doubleDimensionalArray[2][3] = -6;
doubleDimensionalArray[3][5] = 39;
doubleDimensionalArray[4][0] = 91;
doubleDimensionalArray[5][2] = 28;
System.out.println("原二维数组:");
for (int[] ints : doubleDimensionalArray) {
for (int data : ints) {
System.out.printf("%d\t", data);
}
System.out.println();
}
return doubleDimensionalArray;
}
}