稀疏数组学习

稀疏数组

1、稀疏数组简介

1、什么是稀疏数组

当一个数组大部分元素为0，或者为同一个值的数组时，可以使用稀释数组来保存该数组。

2、稀疏数组示例

例：一个数组如下：

注：上图中稀疏数组第一行的行和列值写反了，第0 行应为：6 5 3

原本需要用到 5x6 的数组来保存，现在只需要 3x3 的数组就可以了。

2、稀疏数组应用

1、二维数组转稀疏数组思路

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

2、根据 sum 创建稀疏数组 sparseArr int[sum+1] [3]；

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

2、稀疏数组转二维数组

1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，例如上面的 chessArr = int[6] [5]

2、再读取稀疏数组后面几行的数据，并赋值给原始数据即可。

代码实现：

package com.Lv.sparseArray;

/**
 * @Author: Lv
 * @Description:稀疏数组
 * @Vision: 1.0
 * @Date: Created in 10:24 2020/11/18
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建一个6*5的原始二维数组
        int [][]chessArr = new int[6][5];
        int sum = 0;
        chessArr[1][2] = 3;
        chessArr[3][1] = 5;
        chessArr[4][3] = 4;
        for (int[] row : chessArr) {
            for (int i : row) {
                System.out.print(i+" ");
            }
            System.out.println();
        }

        //将二维数组转化为稀疏数组的思路
        //1、遍历原始二维数组，得到非零的个数
        for (int[] row : chessArr) {
            for (int i : row) {
                if (i!=0){
                   sum++;
                }
            }
        }
        System.out.println("sum===>"+sum);

        //2、创建一个数组作为稀疏数组
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = 6;
        sparseArray[0][1] = 5;
        sparseArray[0][2] = sum;

        //3、遍历原始数组，将有效值取出并放入稀疏数组
        int count = 0;    //用于记录第几个非零数据
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 5; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArr[i][j];
                }
            }
        }
        System.out.println("稀疏数组~~~~~");
        for (int[] ints : sparseArray) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

        //稀疏数组转二维数组思路
        //1、遍历稀疏数组第一行，根据第一行创建二维数组
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];

        //2、遍历稀疏数组后面内容，并相应的赋值给二维数组
        for (int i = 1; i < sparseArray.length; i++) {
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //打印还原后的二维数组
        System.out.println("还原后的二维数组~~~~");
        for (int[] ints : chessArr2) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}

3、进阶之将稀疏数组保存到磁盘文件，再打印出来

package com.Lv.sparseArray;

import java.io.*;

/**
 * @Author: Lv
 * @Description:稀疏数组
 * @Vision: 1.0
 * @Date: Created in 10:24 2020/11/18
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建一个6*5的原始二维数组
        int [][]chessArr = new int[6][5];
        int sum = 0;
        chessArr[1][2] = 3;
        chessArr[3][1] = 5;
        chessArr[4][3] = 4;
        for (int[] row : chessArr) {
            for (int i : row) {
                System.out.print(i+" ");
            }
            System.out.println();
        }

        //将二维数组转化为稀疏数组的思路
        //1、遍历原始二维数组，得到非零的个数
        for (int[] row : chessArr) {
            for (int i : row) {
                if (i!=0){
                   sum++;
                }
            }
        }
        System.out.println("sum===>"+sum);

        //2、创建一个数组作为稀疏数组
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = 6;
        sparseArray[0][1] = 5;
        sparseArray[0][2] = sum;

        //3、遍历原始数组，将有效值取出并放入稀疏数组
        int count = 0;    //用于记录第几个非零数据
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 5; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArr[i][j];
                }
            }
        }
        System.out.println("稀疏数组~~~~~");
        for (int[] ints : sparseArray) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

        //进阶之将稀疏数组存入文件中
        File file = new File("D:\数据结构Data\sparseArray.txt");     //存放数组的文件
        try {
            FileWriter writer = new FileWriter(file);
            for (int i=0;i<4;i++){
                for (int j=0;j<3;j++){
                    writer.write(sparseArray[i][j]+"	");
                }
                writer.write("
");
            }
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //将存的文件读取出来
        int[][] sparseArray2 = new int[4][3];     //用来接收从文件读取的数据
        File file2 = new File("D:\数据结构Data\sparseArray.txt");     //存放数组的文件
        try {
            FileReader reader = new FileReader(file2);
            BufferedReader bf = new BufferedReader(reader);
            String line;      //一行数据
            int row = 0;      //标记行值
            while ((line = bf.readLine()) != null){
                String[] temp = line.split("	");
                for (int i = 0; i < temp.length; i++) {
                    sparseArray2[row][i] = Integer.parseInt(temp[i]);
                }
                row++;
            }
            bf.close();
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //打印从文件读取出来的稀疏数组
        System.out.println("从文件读取的稀疏数组~~~~~");
        for (int[] ints : sparseArray2) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

        //稀疏数组转二维数组思路
        //1、遍历稀疏数组第一行，根据第一行创建二维数组
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];

        //2、遍历稀疏数组后面内容，并相应的赋值给二维数组
        for (int i = 1; i < sparseArray.length; i++) {
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //打印还原后的二维数组
        System.out.println("还原后的二维数组~~~~");
        for (int[] ints : chessArr2) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}