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

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

个人理解：稀疏数组其实就是对二维数组的压缩，当一个二维数组中大部分元素为0，或者大部分元素相同时可以通过稀疏数组来保存该数组。
处理方法：记录数组一共几行几列，有多少个不同的值；把具有不同值的元素的行和列记录在一个小规模数组中，从而达到压缩原数组的目的。

二维数组转稀疏数组思路：
1.遍历原始数组的二维数组，得到有效数据的个数sum
2.根据sum就可以创建稀疏数组sparseArr int[sum+1][3] (为什么是sum+1,因为稀疏数组每一行记录每一个有效数据的信息的同时还会在第一行记录原始数组的总行总列数有效数据个数sum)
3.将二维数组的有效数据存入到稀疏数组中

稀疏数组转二维数组思路：
1.根据稀疏数组的第一行记录的原始数组的总行数，总列数创建二维数组
2.遍历稀疏数组的第一行除外的数据 将有效数据插入到二维数组中对应的位置中（注：数组下标是从0开始，所以稀疏数组中有效数据对应的行和列 保存到二维数组中时要减1）

代码实例：

		```
		package com.尚硅谷数据结构预算法.day01;
		
		import java.io.*;
		
		/**
		 * @Author by lc
		 * @Date 2020/10/20 0020 16:03
		 * @Version 1.0
		 * sparseArray:稀疏数组  当一个二维数组存在大量相同数据
		 * 通过使用压缩的方式对原数组进行压缩
		 * 让第一行的第一列保存原数组总共有多少行，
		 * 让第一行的第二列保存原数组总共有多少列，
		 * 让第一行的第三列保存原数组总共有多少值，
		 * 其余行的第一列表示原数组中行数，第二列表示原数组列数，第三列存储 一二列位置对应的值
		 */
		public class SparseArrayTest1 {
		
		    public static void main(String[] args) throws IOException {
		
		        //1.定义二维数组 六行六列  在二行三列位置存储4，在三行四列存储5
		        System.out.println("----------------1.定义二维数组 六行六列  在二行三列位置存储4，在三行四列存储5-----------------");
		        int[][] arr1 = new int[6][6];
		        arr1[1][2] = 4;
		        arr1[2][3] = 5;
		        for (int i = 0; i < arr1.length; i++) {
		            for (int j = 0; j < arr1.length; j++) {
		                System.out.print(arr1[i][j]);
		            }
		            System.out.println("");
		        }
		        System.out.println();
		        //2.将二维数组存储在磁盘中
		        System.out.println("----------------2.将二维数组存储在磁盘中-----------------");
		
		        //2.1 将二维数组 每一行拼成一个字符串每个元素之间 | 隔开
		        String[] strArr = new String[arr1.length];
		        StringBuilder strBuilder = new StringBuilder();
		        for (int i = 0; i < arr1.length; i++) {
		            for (int j = 0; j < arr1.length; j++) {
		                strBuilder.append(arr1[i][j] + "");
		                strBuilder.append("|");
		            }
		            strArr[i] = strBuilder.toString();
		            strBuilder = new StringBuilder();
		        }
		        //2.2 本地创建文件
		        File arr1File = new File("arr1.txt");
		        FileOutputStream fileOutputStream = null;
		        //PrintStream printStream = null;
		        OutputStreamWriter osw = null;
		        BufferedWriter bufferedWriter = null;
		        try {
		            arr1File.createNewFile();
		            fileOutputStream = new FileOutputStream(arr1File);
		            //解决写入中文字符时的乱码问题
		            osw = new OutputStreamWriter(fileOutputStream, "UTF-8");
		            bufferedWriter = new BufferedWriter(osw);
		            //2.3 循环将字符串写入到磁盘文件中
		            for (int i = 0; i < strArr.length; i++) {
		                bufferedWriter.write(strArr[i] + "\t\n");
		            }
		        } catch (IOException e) {
		            e.printStackTrace();
		        } finally {
		            if (bufferedWriter != null) {
		                bufferedWriter.close();
		            }
		            if (osw != null) {
		                osw.close();
		            }
		            if (fileOutputStream != null) {
		                try {
		                    fileOutputStream.close();
		                } catch (IOException e) {
		                    e.printStackTrace();
		                }
		            }
		        }
		        //3.读取磁盘中的二维数组
		        System.out.println("----------------3.读取磁盘中的二维数组-----------------");
		        //3.1 一行行读取文件
		        FileInputStream fileInputStream = new FileInputStream("arr1.txt");
		        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
		        BufferedReader reader = new BufferedReader(inputStreamReader);
		
		        String line = "";
		
		        String[] arrs = null;
		        StringBuilder stringBuilder = new StringBuilder();
		        while ((line = reader.readLine()) != null) {
		            /*arrs = line.split("|");
		            for (int i = 0; i < arrs.length; i++) {
		                System.out.println(arrs[i]);
		            }*/
		            stringBuilder = stringBuilder.append(line).append(",");
		        }
		        System.out.println(stringBuilder);
		        arrs = stringBuilder.toString().split(",");
		
		        String[] lineArrs = arrs[0].split("\\|");
		        reader.close();
		        inputStreamReader.close();
		        fileInputStream.close();
		        int[][] numArrays = new int[arrs.length][lineArrs.length - 1];
		        int count = 0;
		        for (int i = 0; i < arrs.length; i++) {
		            String[] lineArrs2 = arrs[i].split("\\|");
		            for (int j = 0; j < lineArrs2.length - 1; j++) {
		                numArrays[i][j] = Integer.parseInt(lineArrs2[j]);
		                if (Integer.parseInt(lineArrs2[j]) != 0) {
		                    count = count + 1;
		                }
		            }
		        }
		        System.out.println("从磁盘读取二维数组");
		
		        //4.将二维数组压缩为稀疏数组
		        System.out.println("---------------4.将二维数组压缩为稀疏数组-----------------");
		        int[][] sparseArr = new int[count + 1][3];
		        sparseArr[0][0] = numArrays.length;
		        sparseArr[0][1] = numArrays[0].length;
		        sparseArr[0][2] = count;
		        int nums = 1;
		        for (int i = 0; i < numArrays.length; i++) {
		            for (int j = 0; j < numArrays[0].length; j++) {
		                if (numArrays[i][j] != 0) {
		                    sparseArr[nums][0] = i + 1;
		                    sparseArr[nums][1] = j + 1;
		                    sparseArr[nums][2] = numArrays[i][j];
		                    nums = nums + 1;
		                }
		            }
		        }
		
		        System.out.println("---------------4.将二维数组压缩为稀疏数组---end--------------");
		
		        //5.将稀疏数组存储到磁盘中
		        System.out.println("---------------5.将稀疏数组存储到磁盘中-----------------");
		
		        File sparseArrFile = new File("sparseArrFile.txt");
		        FileOutputStream fileOutputStream1 = new FileOutputStream(sparseArrFile);
		        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream1);
		        BufferedWriter bufferedWriter1 = new BufferedWriter(outputStreamWriter);
		        StringBuilder sparseArrStr = new StringBuilder("");
		        for (int i = 0; i < sparseArr.length; i++) {
		            for (int j = 0; j < sparseArr[0].length; j++) {
		                sparseArrStr.append(sparseArr[i][j]).append("|");
		            }
		            bufferedWriter1.write(sparseArrStr.toString() + "\t\n");
		            sparseArrStr = new StringBuilder("");
		        }
		        bufferedWriter1.close();
		        outputStreamWriter.close();
		        fileOutputStream1.close();
		        
		        System.out.println("---------------5.将稀疏数组存储到磁盘中------end-----------");
		
		        //6.从磁盘中读取稀疏数组
		        System.out.println("---------------6.从磁盘中读取稀疏数组----------------------");
		        //TODO 暂时未实现
		        System.out.println("---------------6.从磁盘中读取稀疏数组------end-----------");
		        
		        
		        //7.将稀疏数组转换为二维数组
		        System.out.println("---------------7.将稀疏数组转换为二维数组------------------");
		        
		        int[][] arrays = new int[sparseArr[0][0]][sparseArr[0][1]];
		        for(int i = 1; i < sparseArr.length; i++){
		            arrays[sparseArr[i][0]-1][sparseArr[i][1]-1] = sparseArr[i][2];
		        }
		        for (int i = 0; i < arrays.length; i++) {
		            for (int j = 0; j < arrays[0].length; j++) {
		                System.out.print(arrays[i][j] + " ");
		            }
		            System.out.println("");
		        }
		        
		        System.out.println("---------------7.将稀疏数组转换为二维数组------end----------");
		    }
		}
		
		```

打印结果如下：
二维数组保存到磁盘中如下：

稀疏数组保存到磁盘文件中效果如下：