Java稀疏数组和二维数组的转换--数据结构的学习

用途：压缩

package algorithm.array;

import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.OutputStream;
import java.util.Arrays;

/**
 * 	稀疏数组
 * 思路：
 * 1.二维数组 -》 稀疏数组
 * 		遍历二维数组，得到有效值个数sum
 * 		将二维数组信息保存在稀疏数组第一行
 * 		二维数组的有效数据保存在稀疏数组中
 * 2.稀疏数组 -》 二维数组
 * 		读取稀疏数组第一行数据，创建二维数组
 * 		读取后续数据赋值给原始的二维数组
 * 3.通过IO将稀疏数据信息保存在文件map.data中
 */
public class SparseArray {

	public static void main(String[] args) {		
		//创建二维数组
		int[][] array = buildArray(9,9);
		//二维数组 》 稀疏数组
		int[][] sparse = transArray(array);
		//稀疏数组 》 二维数组
		int[][] origin = originArray(sparse);
		//IO实现保存稀疏数组, 还原二维数组
		int[][] out = IOutil(sparse);
		//遍历还原的二维数组
		for (int[] is : out) { 
			for (int d : is) { 
				System.out.printf("%d\t", d); 
			}
			System.out.println();
		}
	}

	private static int[][] IOutil(int[][] sparse) {
		try {
			//保存稀疏数组
			OutputStream os = new FileOutputStream("map.data");
			for (int[] row : sparse) {
				
				String rows = Arrays.toString(row);
				String s = rows+"\r\n";
				os.write(s.getBytes());
			}
			//读取稀疏数组并还原
			BufferedReader is = new BufferedReader(new FileReader("map.data"));
			//第一行
			String line = is.readLine();
			//去掉【】并按，取出数据
			String[] s = line.substring(1, line.length()-1).split(",");
			int[][] newArray = new int[Integer.parseInt(s[0].trim())][Integer.parseInt(s[1].trim())];
			//读其他行
			while((line = is.readLine()) != null) {
				String[] ss = line.substring(1, line.length()-1).split(",");
				newArray[Integer.parseInt(ss[0].trim())][Integer.parseInt(ss[1].trim())] = Integer.parseInt(ss[2].trim());
			}
			return newArray;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	private static int[][] originArray(int[][] sparse) {
		//第一行
		int[][] origin = new int[sparse[0][0]][sparse[0][1]];
		//遍历其他行
		for (int i = 1; i < sparse.length; i++) {
			origin[sparse[i][0]][sparse[i][1]] = sparse[i][2];
		}
		return origin;
	}

	private static int[][] transArray(int[][] array) {
		//记录有效值的个数
		int sum = 0;
		for (int[] row : array) {
			for (int data : row) {
				if (data != 0) {
					sum++;
				}
			}
		}
		//创建稀疏数组 并完成第一行的数据
		int[][] sparseArray = new int[sum+1][3];
		sparseArray[0][0] = array.length;
		sparseArray[0][1] = array[0].length;
		sparseArray[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++;
					sparseArray[count][0] = i;
					sparseArray[count][1] = j;
					sparseArray[count][2] = array[i][j];
					
				}
			}
		}
		return sparseArray;
	}

	private static int[][] buildArray(int row, int col) {		
		int[][] a = new int[row][col];
		//有效值
		a[1][3] = 19;
		a[3][6] = 8;
		a[5][6] = 12;
		return a;
	}

}