学习稀疏数组的心得与体会（java实现）

最近新学习了稀疏数组，对稀疏数组有了一个较为深刻的理解，稀疏数组可以将数据压缩存储，节省空间，之后需要时将数组解压即可。那么下面我们就来实现一下稀疏数组吧。

稀疏数组

我们先来说一下稀疏数组的概念：
记录原始二维数组的行列数，并记录原始二维数组中的值的个数并创建n行3列的数组，第一行记录原始二维数组的行列数和值的个数，其余各行记录值所在的行和列还有值的大小
下面我们用代码来进行实现

1. 首先我们可以这样来想，我们可以把一个二维数组想象成一个n行n列的棋盘，那么我们用1来代表黑子，2来代表蓝子创建一个棋盘出来，这里创建一个11*11的二维数组

public class SparseArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//首先创建一个二维数组，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();
		}
}

2. 那么根据原始数组我们就能够得到原始数组中的有效数据的个数，通过有效数据的个数，我们就可以创建稀疏数组

//遍历二维数组，找到二维数组中不为0的数
		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);
		//创建稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0] = 11;
		sparseArr[0][1] = 11;
		sparseArr[0][2] = sum;
		//将二维数组中的数据记录到稀疏数组中去
		int count = 0;//用于记录是第几个非0数据
		for(int i = 0; i < 11; i++)
		{
			for (int j = 0; j < 11; j++) {
				if(chessArr1[i][j] != 0) {
					count++;
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					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]);
		}

3. 我们在这里采用文件读写的形式来对稀疏数组进行保存和读取，首先我们先创建将文件写入磁盘的方法

//将稀疏数组存储到磁盘
	public static void sparseArrayToIo(int[][] sparseArray) throws Exception {
        File file = new File("sparseArray.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        FileWriter writer = new FileWriter(file);
        for(int i =0; i < sparseArray.length; i++) {
            for(int j = 0; j < 3; j++) {
                writer.write(sparseArray[i][j]);
            }
        }
        writer.flush();
    }

4. 再创建将文件读取出来的方法

/*读文件获取稀疏数组，
  这个只能传入稀疏数组的行数，并不能动态的获悉稀疏数组的行数
  在调用此方法时可以将获取的原始数组的有效数据个数+1来获取稀疏数组的行数*/
    public static int[][] sparseArrayFromIo(int lineNums) throws Exception {

        FileReader reader = new FileReader("sparseArray.txt");
        int getNum = 0;
        int[][] sparseArray = new int[lineNums][3];
        for(int i = 0;i < lineNums;i++) {
            for (int j = 0; j < 3; j++) {
                getNum = reader.read();
                sparseArray[i][j] = getNum;
            }
        }
        return sparseArray;
    }

5. 此时我们将刚刚写好的稀疏数组存到文件中去

//将稀疏数组写入文件
		try {
			sparseArrayToIo(sparseArr);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}

6. 最后，存入文件中的稀疏数组读取出来，并进行还原，将其还原为原始数组，也就是解压

        //将稀疏数组还原为二维数组
		//第一步读取稀疏数组中的所记录的行和列的个数创建二维数组
		System.out.println();
		System.out.println("解压之后的二维数组是");
		
		 //读取磁盘中的稀疏数组
        try {
            int[][] sparseArrFromIo = sparseArrayFromIo(sum + 1);
            //从文件所保存的稀疏数组中获取原始行列式的行列信息
            //因为在稀疏数组中第一行第一列和第一行第二列保存的是原始行列式的行列信息，所以直接获取即可
            int[][] newChessArr = new int[sparseArrFromIo[0][0]][sparseArrFromIo[0][1]];
            //第二步读取稀疏数组中所保存的值
            for(int i = 1; i < sparseArrFromIo.length; i++){
                newChessArr[sparseArrFromIo[i][0]][sparseArrFromIo[i][1]] = sparseArrFromIo[i][2];
            }
            //遍历刚转回的原始数组
            for(int[] row : newChessArr){
                for(int item : row){
                    System.out.printf("%d\t",item);
                }
                System.out.println();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }