数据结构篇之稀疏数组

原始的二维数组转稀疏数组的思路

1. 遍历原始的二维数组，得到有效数据的个数sum
2. 根据sum就可以创建稀疏数组sparseArr int[sum+ 1][3]
3. 遍历原始数组并判断有效数据
4. 将二维数组的有效数据数据存入到稀疏数组

稀疏数组转原始的二维数组的思路

1. 先读取稀疏数组的第一行，根据第一行的数据 ，创建原始的二维数组
2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

对稀疏数组结构的剖析：

1.稀疏数组的大小：
假设一个稀疏数组为sparseArr[x][y]
x代表的行数要怎么定义呢：原始数组中有效数据的个数（此时拟为sum），再在此基础上+1（加的第一行来分别记录着原始数组大小的行数、列数、和原始数组中有效数据的个数）所以此处的x就应为sum+1
y代表的列数要怎么定义呢：其列数恒定为3，分别代表行、列、值
所以综上：稀疏数组的大小应为：sparseArr[sum+1][3]

2.稀疏数组的规则：
1）稀疏数组的第一行：
必须分别记录着 原始数组的行数、原始数组的列数、原始数组中有效数据的个数。
2） 稀疏数组的其他行：每一行分别记录着 某个有效数据所在的行数、某个有效数据所在的列数、某个有效数据的值。

下面为大家展示详细的模拟棋盘代码实例（其中都有相关详细讲解）

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author Savior.D
 *
 */
public class Demo_SparseArray {
	public static void main(String[] args) throws IOException {
		
		//创建原数组
		//0为空值，1为黑色棋子，2为蓝色棋子
		int chessArr [][]=new int [11][11];
		int arr[]=new int [1];
		
		//落子的位置
		chessArr[1][2]=1;
		chessArr[2][3]=2;
		
		System.out.println("原数组(棋盘)");
		for (int[] is : chessArr) {
			for (int i : is) {
				System.out.print(i+"  ");
			}
			System.out.println();
		}
		
		System.out.println("\n");
		
		//记录获取原数组中有效数值的个数
		int sum=0;
		for (int[] is : chessArr) {
			for (int i : is) {
				int num=i;
				if(num!=0) {
					sum++;
				}
			}
		}
		//建立稀疏数组
		//1.根据原数组中的有效数值个数设定行数，列数为3恒定不变
		int sparseArr[][]=new int[sum+1][3];
		
		//设定稀疏数组的第一行的数据分别为原数组的行数、列数、有效数值个数
		sparseArr[0][0]=chessArr.length;
		sparseArr[0][1]=chessArr[0].length;//注意在一些场景需要判断数组是否为空，若为空则数组名[0]所代表的子数字不存在，会报错。（此处忽略）
		sparseArr[0][2]=sum;
		
		//为稀疏数组其他行列分别填上原数组中有效数值的所在行、列，和该数值
		int count=1;//稀疏数组起始填的索引
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j <11; j++) {
				//判断原数组中的有效数值
				if(chessArr[i][j]!=0) {
					//为稀疏数组每一行依次填上相应的数据
					sparseArr[count][0]=i;//填上原数组某个有效数值所在的行数
					sparseArr[count][1]=j;//填上原数组某个有效数值所在的列数
					sparseArr[count][2]=chessArr[i][j];//填上原数组某个有效数值的值
					count++;//填完一行换下一行
				}
			}
		}
		
		//稀疏数组(压缩存盘后的棋盘)
		System.out.println("稀疏数组(压缩存盘后的棋盘)");
		for (int[] is : sparseArr) {
			for (int i : is) {
				System.out.print(i+"  ");
			}
			System.out.println();
		}
		
		System.out.println("\n");
		
		
		//将稀疏数组读取到磁盘的文件中
		FileOutputStream fos = new FileOutputStream(new File("a.txt"));

		for (int[] is : sparseArr) {
			for (int i : is) {
				fos.write(i);
			}
		}
		
		fos.close();
		
		//将稀疏数组从磁盘的文件中读取出来
		FileInputStream fis = new FileInputStream(new File("a.txt"));
		
		int sparseArr2[][]=new int[sum+1][3];
		for (int i = 0; i < sparseArr2.length; i++) {
			for (int j = 0; j < sparseArr2[i].length; j++) {
				sparseArr2[i][j]=fis.read();
			}
			
		}
		fis.close();
		
		System.out.println("从磁盘中读取的稀疏数组");
		for (int[] is : sparseArr2) {
			for (int i : is) {
				System.out.print(i+" ");
				
			}
			System.out.println();
		}
		
		System.out.println("\n");
		
		//将稀疏数组恢复成原数组
		//1.恢复成原来的数组大小
		int chessArr2[][]=new int [sparseArr2[0][0]][sparseArr2[0][1]];
		
		/*2.将有效数值恢复到原来的位置
		 * 1)从稀疏数组的第一行开始遍历
		 * 2)为原数组对应上的 行、列 赋上 对应的值
		 * */
		for (int i = 1; i < sparseArr2.length; i++) {
			
			chessArr2[sparseArr2[i][0]][sparseArr2[i][1]]=sparseArr2[i][2];
		}
		
		//原棋盘2
		System.out.println("从稀疏数组恢复后的原数组(棋盘)");
		for (int[] is : chessArr2) {
			for (int i : is) {
				System.out.print(i+"  ");
			}
			System.out.println();
		}
	}
}

代码结果：

总结：这种数据结构可以帮助我们在某些应用场景极大的压缩所需内存~

希望这篇文章能对你有所帮助，觉得还可以的可以点个赞支持一下~