Java数据结构与算法-----稀疏数组

在我们平常的应用中，稀疏数组是一种常用的数据结构。
例如：在我们进行五子棋游戏时，如果中途有事需要离开，那么可以对他进行保存，以便事情结束后能接着继续玩。那么如何存储呢？首先我们会想到的是利用二维数组，我们可以把棋盘看成二维数组进行存储，但如果棋盘很大，而我们落子很少呢？那么存储整个棋盘就显得浪费空间了，因此，我们可以使用稀疏数组。

那么什么是稀疏数组呢？

1. 稀疏数组也是二维数组，它是一种数据结构。
2. 假设棋盘现由n个子落下，那么稀疏数组是一个(n+1)*3的二维数组
3. 它的第一行第一列是棋盘的行数，第一行第二列是棋盘的列数，第一行第三列是落子的数量
4. 接下来的每一行的三列分别是落下的子的行数，列数与值
   例如二维数组0 1 0 0 0 其中1、2代表该位置落子,分别为黑棋和白棋
   2 0 0 0 0
   0 0 1 0 0
   0 2 0 0 0

那么它的系数数组为row clo value
4 5 4
0 1 1
1 0 2
2 2 1
3 1 2

package 数据结构;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class 稀疏数组 {

	public static void main(String[] args) {
		//创建一个原始的11 * 11 的二维数组 其中0表示没有棋子，1表示黑，2表示白
		int chessArr1[][] = new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		chessArr1[3][4]=2;
		//输出原始的二维数组
		for(int[] row : chessArr1) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		//将原始的二维数组转换为稀疏数组 1.遍历数组，得到有效数据的个数
		int sum=0;
		for(int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(chessArr1[i][j]!= 0) {
					sum++;
				}
			}
		}
		System.out.println("二维数组有效数据的个数为：" + sum+"个");
		//创建对应的稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=sum;
		int count=1; //
		for(int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(chessArr1[i][j]!=0) {
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=chessArr1[i][j];
					count++;
				}
			}
		}
		System.out.println();
		System.out.println("得到的稀疏数组为：");
		for(int[] row : sparseArr) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		//把稀疏数组写入文件
		try {
			FileWriter fw = new FileWriter("d:\\array.txt");
			//BufferedWriter bw = new BufferedWriter(fw);
			for(int i=0;i<sum+1;i++) {
				for(int j=0;j<3;j++) {
					fw.write(sparseArr[i][j]+"\t");
				}
				fw.write("\r\n");
			}
			fw.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//把稀疏数组恢复为原来的二维数组
		//先从文件内读出稀疏数组
		int [][]sparseArr1=new int[sum+1][3];
		try {
			BufferedReader br = new BufferedReader(new FileReader("d:\\array.txt"));
			String line;
			int row=0;
			while((line=br.readLine())!=null) {
				String[] temp=line.split("\t");
				for(int i=0;i<temp.length;i++) {
					sparseArr1[row][i]=(int) Double.parseDouble(temp[i]);
				}
				row++;
			}
			br.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("从文件读取后的数组为：");
		for(int[] row : sparseArr1) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		//因为稀疏数组的第一行第一列为二维数组的行数，第二列为二维数组的列数  所以
		int chessArr2[][] = new int[sparseArr1[0][0]][sparseArr1[0][1]];
		for(int i=1;i<sparseArr.length;i++) {
			chessArr2[sparseArr1[i][0]][sparseArr1[i][1]]=sparseArr1[i][2];
		}
		System.out.println();
		System.out.println("恢复后的二维数组为：");
		for(int[] row : chessArr2) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
	}

}