稀疏数组小记

稀疏数组

---

问题引入

---

基本介绍

• 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方法是:
  • 1.记录数组一共有几行几列，有多少个不同的值
  • 2.把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

---

实例应用

• 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
• 把稀疏数组存盘，并且可以从新恢复原来的二维数组
• 数整体思路分析
  

实现代码

package com.atguigu.sparsearray;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class SparseArray {

	public static void main(String[] args) {
		
		SparseArray sparse = new SparseArray();
		
		// 创建一个原始的二维数组 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();
		// }

		for (int[] row : chessArr1) {
			for (int data : row) {
				System.out.print(data + "\t");
			}
			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 = " + sum);

		// 2.创建对应的系数数组
		int sparseArr[][] = new int[sum + 1][3];
		// 给稀疏数组赋值
		sparseArr[0][0] = 11; // 存着二维数组有多少row
		sparseArr[0][1] = 11;// 存着二维数组有多少rcol
		sparseArr[0][2] = sum;

		// 遍历二维数组，将非零的值存放到稀疏数组中
		int count = 0; // 作用:count用于记录是第几个非零数据
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr1[i][j] != 0) { // i = 1,j = 2
					count++;
					sparseArr[count][0] = i;// 相当于将二维数组中数组的row值存起来
					sparseArr[count][1] = j;// 相当于将二维数组中数组的col值存起来
					sparseArr[count][2] = chessArr1[i][j];
				}
			}
		}

		// 输出稀疏数组的形式
		System.out.println();
		System.out.println("得到的稀疏数组为：");
		for (int i = 0; i < sparseArr.length; i++) {
			// System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
			for (int j = 0; j < sparseArr[i].length; j++) {
				System.out.print(sparseArr[i][j] + "\t");
				// System.out.printf("%d\t", data);

			}
			System.out.println();
		}
		System.out.println("稀疏数组打印完毕...");
		System.out.println("****************将稀疏数组存放到磁盘中****************************");
		
		
		//调用写出稀疏数组的方法
		String fileWritePath="E:\\B站Java学习资料存放\\算法与数据结构\\笔记代码课件资料\\课件\\emp.data";
		sparse.writeSparseArray(fileWritePath, sparseArr);
		
		System.out.println("******************稀疏数组存到磁盘中完毕*************************");
		//将磁盘中的稀疏数组读取出来
		int[][] readSparseArray = sparse.readSparseArray(fileWritePath);
		/// 将稀疏数组转化为二维数组
		// 1.读取稀疏数组的第一行，根据第一行的数据创建二维数组
		int chessArr2[][] = new int[readSparseArray[0][0]][sparseArr[0][1]];

		// 2.读取稀疏数组的后几行数据（从第二行开始），并赋值给原始的二维数组
		for (int i = 1; i < sparseArr.length; i++) {
			int j = 0;
			chessArr2[sparseArr[i][j]][sparseArr[i][j + 1]] = sparseArr[i][j + 2];

		}

		
		
		
		// 恢复后的二维数组
		System.out.println();
		System.out.println("恢复后的二维数组");

		for (int[] data1 : chessArr2) {
			for (int data : data1) {
				System.out.printf("%d\t", data);
			}
			System.out.println();

		}

	}
	/**
	 * 
	 * @param filePath 输入文件路径
	 * @param sparseArr 要输出的稀疏数组
	 * @return 是否输出成功
	 */
	public boolean writeSparseArray(String fileWritePath,int[][] sparseArr ){
		// 2.创建对应的流
				FileWriter fw = null;

				try {
					// 将稀疏数组存到磁盘中去
					// 1.指定打印的文件
					File file = new File(fileWritePath);
					if (!(file.exists())) {
						System.out.println("文件不存在创建中...");
						file.createNewFile();
						System.out.println("文件创建成功");
					}
					fw = new FileWriter(file);
					// 3.对应的具体写出操作
					// 遍历稀疏数组
					 for (int i = 0; i < sparseArr.length; i++) {
//						 fw.write(sparseArr[i][0] + "\t" + sparseArr[i][1] + "\t" + sparseArr[i][2] + "\r\n" );
						 for(int j = 0 ; j < sparseArr[i].length; j++){
							 fw.write(sparseArr[i][j] + "\t"); 
						 }
						 fw.write("\r\n");

						 
					}
					
				} catch (Exception e) {
					e.printStackTrace();
					return false;
				} finally {

					// 4.关闭流
					try {
						fw.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
						return false;
					}
				}
				
		return true;
	}
	
	
	/**
	 * 读入稀疏数组
	 * @param readFilePath 读入文件的路径
	 * @return 返回一个稀疏数组
	 */
	public int[][] readSparseArray(String readFilePath){
		BufferedReader br = null;
		// 创建稀疏数组
		int[][] sparseArray = null;
		try {

			// 1.创建处理流
			br = new BufferedReader(
					new FileReader(new File(readFilePath)));

			// 2.读入文件
			boolean isNotRead = false;// 控制sparseArray数组只创建一次
			String str;// 装从文件中遍历出来的数据
			int curCount = 0;
			int len;
			while ((str = br.readLine()) != null) {// 使用readLine的原因是因为它不包含换行符
				String[] split = str.split("\t");
				if (!isNotRead) {
					// 根据磁盘中文件将稀疏数组创建起来：isNotRead--》控制只创建一次
					sparseArray = new int[Integer.parseInt(split[2]) + 1][3];
					sparseArray[curCount][0] = Integer.parseInt(split[0]);
					sparseArray[curCount][1] = Integer.parseInt(split[1]);
					sparseArray[curCount][2] = Integer.parseInt(split[2]);
					curCount++;
					isNotRead = true;
				} else {
					sparseArray[curCount][0] = Integer.parseInt(split[0]);
					sparseArray[curCount][1] = Integer.parseInt(split[1]);
					sparseArray[curCount][2] = Integer.parseInt(split[2]);
					curCount++;
				}

			}
			System.out.println("**********成功写出*************");
		} catch (IOException e) {
			e.printStackTrace();

		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

		}

		return sparseArray;
		
	}
	
}