稀疏数组（java）

​​​​​​​

稀疏数组

因为二维数组的很多值是默认值0，因此记录了很多没有意义的数据->稀疏数组（永远是三列，行数不定）

稀疏数组的第一行记录数组一共有几行几列，有多少个不同的值，把具有不同值的元素的行列及值记录在一个小规模的数组（稀疏数组）中，从而缩小程序的规模

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

1.遍历原始的二维数组，得到有效数据的个数sum

2.根据sum就可以创建稀疏数组sparseArr int【sum+1】【3】

3.将二维数组的有效数据存入到稀疏数组

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

1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 int【6】【7】
2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组

package com.wang;

import java.io.*;

public class SparseArr {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//生成一个默认的棋盘，0代表没有棋子，1代表黑子，2代表白子
		int[][] chessA1=new int[11][11];
		chessA1[1][2]=1;
		chessA1[2][3]=2;
		//输出默认数组
		for(int[]row:chessA1) {
			for(int data:row) {
				System.out.print(data);
			}
			System.out.println();
		}
		
		//二维数组转稀疏数组
		//遍历整个数组得到非零数的个数
		int sum=0;
		for(int[]row:chessA1) {
			for(int data:row) {
				if(data!=0) {
					sum++;
				}
			}
		}
		
		//将二维数组的有效数据存入稀疏数组
		
		//对该数组的第一行进行初始化
		int[][] spraseA1=new int[sum+1][3];
		spraseA1[0][0]=chessA1.length;
		//获取行长
		spraseA1[0][1]=chessA1[0].length;
		//获取列长
		spraseA1[0][2]=sum;
		
		//保存数据
		//a用来记录第几个非零数据，第零行用于存储行数和列数和非零数的个数了，所以从一开始
		int a=1;
		for (int i = 0; i < chessA1.length; i++) {
			for (int j = 0; j < chessA1[i].length; j++) {
				if (chessA1[i][j]!=0) {
					spraseA1[a][0]=i;
					spraseA1[a][1]=j;
					spraseA1[a][2]=chessA1[i][j];
					a++;
				}
			}
		}
		//输出存储好的稀疏数组
		for(int[]row:spraseA1) {
			for(int data:row) {
				System.out.print(data+" ");
			}
			System.out.println();
		}
		
		//稀疏数组转二维数组
		//首先根据第一行的内容生成数组
		int[][] chessA2=new int[spraseA1[0][0]][spraseA1[0][1]];
		for (int i = 1; i < spraseA1.length; i++) {
			// ！！！ chessA2[行][列]=结果
			chessA2[spraseA1[i][0]][spraseA1[i][1]]=spraseA1[i][2];
		}
		
		//输出还原的二维数组
		for(int[]row:chessA2) {
			for(int data:row) {
				System.out.print(data);
			}
			System.out.println();
		}
		
		
		//将稀疏数组导出IO
		try {
			File f = new File("e:\\sprase.txt");
			FileOutputStream fos = new FileOutputStream(f);
			OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
			for(int i = 0; i < spraseA1.length; i++) {
				osw.write(spraseA1[i][0] + "," + spraseA1[i][1] + "," + spraseA1[i][2] + ",");
			}
			//关闭输出流
			osw.close();
			fos.close();
			System.out.println("存储完毕");
			
			
		//从文件中读取稀疏数组
			FileInputStream fis = new FileInputStream(f);
			InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
			StringBuffer sb = new StringBuffer();
			while(isr.ready()) {
				sb.append((char)isr.read());
			}
			//关闭输入流
			isr.close();
			fis.close();
			System.out.print("读取到的内容为:");
			//将数据存入数组以，为分隔符
			String[] sb1 = sb.toString().split(",");
			for(String i:sb1) {
				System.out.print(i+" ");
			}
			
			
		//还原稀疏数组
			
			//存入sb1中的数据在同一行，而稀疏数组每一行只有3个数，长度除以3就可以确定稀疏数组有几行
			int[][] spraseA2=new int[sb1.length/3][3];
			//还原第一行
			
			//因为稀疏数组保存的是整数所以要转换
			spraseA2[0][0]=Integer.parseInt(sb1[0]);
			spraseA2[0][1]=Integer.parseInt(sb1[1]);
			spraseA2[0][2]=Integer.parseInt(sb1[2]);
			int sum1=1;
			for (int i = 3; i < sb1.length; i+=3,sum1++) {
				spraseA2[sum1][0]=Integer.parseInt(sb1[i+0]);
				spraseA2[sum1][1]=Integer.parseInt(sb1[i+1]);
				spraseA2[sum1][2]=Integer.parseInt(sb1[i+2]);
			}
			
			System.out.println("\n还原后的稀疏数组为:");
			for(int[] row:spraseA2) {
				for(int data:row) {
					System.out.print(data+" ");
				}
				System.out.println();
			}
		} catch (Exception e) {}
	}
	
}

​​​​​​​