数据结构之稀疏数组，保存到磁盘，从磁盘中读取

稀疏数组保存到磁盘，从磁盘中读取

一、数据结构包括：线性结构和非线性结构

① 线性结构
（1）、线性数据结构作为最常见的数据结构，其特点是数据元素之间存在一对一的线性关系
（2）、线性数据结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表），顺序存储的线性表称为顺序表，顺序表中存储的元素是连续的。
（3）、链式存储的线性表称之为链表，链表中存储的元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址值。
（4）、线性结构常见的有：数组、队列、链表和栈
② 非线性结构
（1）、非线性结构包括、二维数组，多维数组，广义表，树结构，图结构

二、稀疏数组（sparse array）

1）、当一个数组中有大部分元素为一个值时，可以使用稀疏数组来保存改值，
2）、稀疏数组的处理办法是：
a．记录数组一共有几行几列，有多少个不同的值
b．把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

3）、应用场景五子棋

原始的二位数组，有很多没有意义的数据，所以使用稀疏数组。


4）、二维转稀疏数组的思路
a．遍历原始的二维数组，得到有效数据的个数sum
b．根据sum可以创建稀疏数组sparseArr int[sum+1,3]
c．将二维数组的有效数据存到稀疏数组中
d．最后把稀疏数组放到文件中保存起来，做到存盘

5）、 稀疏数组转二维数组
a．从文件中解析出稀疏数组
b．先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 int [11][11]
c．在读取稀疏数组后几行的数组，并赋予给原始的二维数组即可
d．做到复盘

补充知识点：/与%，除与取模

三、代码实现

import java.io.*;
public class SparseArray {
	public static void main(String[] args) throws Exception {
		//创建一个原始的二维数组 11*11，0表示没有棋子，1表示黑子，2表示白字
		int chessArr1[] []= new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		//输出原始的二维数组
		System.out.println("原始的二维数组");
		for (int[] row: chessArr1) {
			for (int data:row){
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		// 将二维数组转稀疏数组
		//① 先遍历二维数组得到非0的数据个数
		int sum = 0;
		for (int i = 0; i < chessArr1.length; i++) {
			for (int j = 0; j < chessArr1.length; j++) {
				if (chessArr1[i][j]!=0){
					sum++;
				}
			}
		}
		//创建对应的稀疏数组
		int sparseArr[][]=new int[sum+1][3];

		//给稀疏数组赋值
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=sum;

		//遍历二维数组，将非零的值存放到稀疏数组中。
		int count = 0; //count用于记录是第几个非零数据
		for (int i = 0; i < chessArr1.length; i++) {
			for (int j = 0; j < chessArr1.length; j++) {
				if (chessArr1[i][j]!=0){
					count++;
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=chessArr1[i][j];
				}
			}
		}

		//输出稀疏数组的形式,%d\t每个一个值换行
		System.out.println("得到的稀疏数组如下+++++++++++++++++");
		for (int i = 0; i < sparseArr.length; i++) {
			System.out.printf("%d\t%d\t%d\t",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
			System.out.println();
		}
		//将稀疏数组写入文件中，文件名为map.data
		System.out.println("将稀疏数组写入文件map.data中");
		File file = new File("D:\\尚硅谷韩顺平老师数据结构分享\\map.data");
		FileOutputStream outputStream = new FileOutputStream(file);
		OutputStreamWriter writer = new OutputStreamWriter(outputStream,"utf-8");
		for (int i = 0; i < sparseArr.length; i++) {
			if (i== sparseArr.length-1){
				writer.write(sparseArr[i][0]+","+sparseArr[i][1]+","+sparseArr[i][2]);
			}else {
				writer.write(sparseArr[i][0]+","+sparseArr[i][1]+","+sparseArr[i][2]+",");
			}
		}
		writer.close();
		outputStream.close();
		System.out.println("写入成功");


		// 稀疏数组转二维数组,首先读取文件
		FileInputStream inputStream = new FileInputStream(file);
		InputStreamReader reader = new InputStreamReader(inputStream,"utf-8");
		StringBuffer sb = new StringBuffer();
		while (reader.ready()){
			sb.append((char) reader.read());//加入stringbuffer，转为char,不然只会打印地址
		}
		System.out.println("读出的文件"+sb.toString());
		reader.close();
		inputStream.close();

		//把读出的文件，赋值给稀疏数组
		String[] str = sb.toString().split(",");
		System.out.println(str.length/3);
		int sparseArray3[][]= new int[str.length/3][3];
		int i= 0;
		for (String  s:str) {
			System.out.println(i%3);
			sparseArray3[i/3][i%3] =Integer.parseInt(s);
			i++;
		}

		//输出读取到的稀疏数组
		System.out.println("输出读取到的稀疏数组如下+++++++++++++++++");
		for (int k = 0; k < sparseArray3.length; k++) {
			System.out.printf("%d\t%d\t%d\t",sparseArray3[k][0],sparseArray3[k][1],sparseArray3[k][2]);
			System.out.println();
		}
		//①先读取稀疏数组第一行，找出二维数组多大
		int charArray2[][]= new int[sparseArray3[0][0]][sparseArray3[0][1]];

		//②读取稀疏数组中的值，给到二维数组,从第二行开始，第一行存的是多少row ，多少列，有几个有效值
		for (int l = 1; l < sparseArr.length; l++) {
				charArray2[sparseArr[l][0]][sparseArray3[l][1]]=sparseArray3[l][2];

		}

		//恢复后的二维数组
		System.out.println("恢复后的二维数组");
		for (int[] row:charArray2) {
			for (int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();

		}
	}
}