定义
当一个数组中大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组.
如 : 五子棋,每个位置的默认值为0,当棋手在落子的时候会改变棋盘数据.当我们需要对棋盘进行存盘时.我们不需要把所有的位置数据都记录到硬盘中.只需要把落子的数据存盘就可以.这样存盘可以节省一定量的内存空间.稀疏数组就是专门做这件事情的。
处理方法
1 : 记录数组一共有几行几列.有多少个不同的值
2 : 把存有不同值的元素的行列及值记录在一个小规模的数组中.从而缩小程序的规模.
原本的二维数据中我们一个有6行7列.共42个值.当我们用稀疏数组去存储这个数组的值时.
如右图,第一行用来记录该数据一共有多少个值.其中非0的有几个(如图为8),
后面每一组记录每个坐标的位置与值.
这样我们就把原先需要存储42个值的内存压缩到了27个.这样节省了内存
处理过程
1.构造一个普通二维数组
2.计算这个普通二维数组中有效数据个数sum个
3.构造稀疏数组
4.输出稀疏数组
5.对稀疏数组还原
1.构造一个普通二维数组
//定义一个普通二维数组(八行八列)随机初始化三个元素
int array[][] = new int[8][8];
array[1][1] = 8;
array[2][2] = 5;
array[3][3] = 9;
2.计算普通数组中有效数据个数
//计算普通数组中有多少个有效数据
int sum = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (array[i][j] != 0) {
sum++;
}
}
}
3.构造稀疏数组
//构造稀疏数组
int SpareseArray[][] = new int[sum + 1][3];
SpareseArray[0][0] = array.length;
SpareseArray[0][1] = array[0].length;
SpareseArray[0][2] = sum;
int count = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (array[i][j] != 0) {
count++;
SpareseArray[count][0] = i;
SpareseArray[count][1] = j;
SpareseArray[count][2] = array[i][j];
}
}
}
4.输出稀疏数组
//输出稀疏数组
System.out.println(" ===================================");
for (int i[] : SpareseArray) {
for (int j : i) {
System.out.print(j + " ");
}
System.out.print("\n");
}
5.还原稀疏数组
//还原系稀疏矩阵
int array2[][]=new int[SpareseArray[0][0]][SpareseArray[0][1]];
for (int i = 1; i < SpareseArray.length; i++) {
array2[SpareseArray[i][0]][SpareseArray[i][1]]= SpareseArray[i][2];
}
6.打印还原后的稀疏数组
//打印还原后的稀疏矩阵
System.out.println(" ===================================");
for (int i[] : array2) {
for (int j : i) {
System.out.print(j + " ");
}
System.out.print("\n");
}
全部源码:
package com.zeng.array;
//稀疏数组
public class SparseArraysDemo23 {
public static void main(String[] args) {
//定义一个普通二维数组
int array[][] = new int[8][8];
array[1][1] = 8;
array[2][2] = 5;
array[3][3] = 9;
//输出普通数组
for (int i[] : array) {
for (int j : i) {
System.out.print(j + " ");
}
System.out.print("\n");
}
//计算普通数组中有多少个有效数据
int sum = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (array[i][j] != 0) {
sum++;
}
}
}
//构造稀疏数组
int SpareseArray[][] = new int[sum + 1][3];
SpareseArray[0][0] = array.length;
SpareseArray[0][1] = array[0].length;
SpareseArray[0][2] = sum;
int count = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (array[i][j] != 0) {
count++;
SpareseArray[count][0] = i;
SpareseArray[count][1] = j;
SpareseArray[count][2] = array[i][j];
}
}
}
//输出稀疏数组
System.out.println(" ===================================");
for (int i[] : SpareseArray) {
for (int j : i) {
System.out.print(j + " ");
}
System.out.print("\n");
}
//还原系稀疏矩阵
int array2[][] = new int[SpareseArray[0][0]][SpareseArray[0][1]];
for (int i = 1; i < SpareseArray.length; i++) {
array2[SpareseArray[i][0]][SpareseArray[i][1]] = SpareseArray[i][2];
}
//打印还原后的稀疏矩阵
System.out.println(" ===================================");
for (int i[] : array2) {
for (int j : i) {
System.out.print(j + " ");
}
System.out.print("\n");
}
}
}