稀疏数组和二维数组之间的转换

稀疏数组

1.1 基本介绍

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

1.2 稀疏数组的处理方法

1. 记录原始二维数组一共有几行几列，以及有多少个不同的值
2. 把值不相同的元素的行和列以及元素的值记录在一个小型数组当中

1.3 二维数组转换为稀疏数组的思路分析：

1. 遍历原始的二维数组，得到值不相同的元素个数 sum
2. 根据sum创建稀疏数组spaarseArray int[sum + 1][3]
3. 将二维数组的sum个元素存入到稀疏数组当中

1.4 代码实现

public class SparseArray {
	private static int chessArr_1[][];
    private static int chessArr_2[][];
    private static int sparseArr[][];
    private static int sum = 0; //有效数据的个数

    public static void main(String[] args) {
        //创建一个原始的二维数组 11 * 11
        //0：表示没有棋子  1：表示黑棋  2：表示白棋
        chessArr_1 = new int[11][11];
        chessArr_1[1][2] = 1;
        chessArr_1[2][3] = 2;
        chessArr_1[4][5] = 2;

        //输出原始的二维数组
        System.out.println("原始的二维数组:");
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                int value = chessArr_1[i][j];
                System.out.print(value + "\t");
            }
            System.out.println();
        }
        
        /**
         * 将原始二维数组转化为稀疏数组
         */
        //1、遍历二维数组，得到有效数据(非0)的个数sum
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr_1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("sum = " + sum);
        //2、根据sum创建稀疏数组
        sparseArr = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        //遍历原始二维数组，将非0的值放到sparseArr数组中
        int count = 1; //count 用于记录是第几个非0数据
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr_1[i][j] != 0){
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr_1[i][j];
                    count++;
                }
            }
   		 }
        //输出稀疏数组矩阵
        System.out.println("稀疏数组：");
        for (int i = 0; i < count; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(sparseArr[i][j] + "\t");
            }
            System.out.println();
        }
}

1.5 将稀疏数组存入.txt文件当中的代码实现

/**
 * 将稀疏数组存入.txt文件
 * @param array
 */
public static void saveArray(int[][] array){
    FileWriter fileWriter = null; //创建字符输出流
    try {
        //数据想写入的路径以及文件
        File file = new File("D:\\JavaIDEA\\DataStructures","SparseArr.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
        //给字节输出流赋予实例
        fileWriter = new FileWriter(file);
        //通过循环将数组写入txt文件中
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                fileWriter.write(array[i][j] + "\t");
            }
            fileWriter.write("\n");
        }
        fileWriter.flush(); //刷新
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (fileWriter != null) {
                fileWriter.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.6 将txt文件中的数据转为稀疏数组

/**
 * 将txt文件中的数据转为稀疏数组
 * @return
 */
public static int[][] readArray(){
    FileReader fileReader = null; //声明一个字符输入流
    BufferedReader bufferedReader = null; //声明字符输入缓冲流
    int[][] array = null;
    try {
        //指定读取路径
        fileReader = new FileReader("D:\\JavaIDEA\\DataStructures\\SparseArr.txt");
        bufferedReader = new BufferedReader(fileReader); //包装字符输入流
        List<String> list = new ArrayList<>(); //存放读取文件的数据
        //逐行读取文件数据
        String lineString = null;
        while ((lineString = bufferedReader.readLine()) != null){
            list.add(lineString);
        }
        //获取数组有多少行
        int lineNum = list.size();
        //获取数组有多少列
        String str = list.get(0);
        int columnNum = str.split("\t").length;
        array = new int[lineNum][columnNum];
        for (int i = 0; i < lineNum; i++) {
            for (int j = 0; j < columnNum; j++) {
                String[] string = list.get(i).split("\t");
                array[i][j] = Integer.valueOf(string[j]);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (bufferedReader != null){
                bufferedReader.close();
            }
            if (fileReader != null){
                fileReader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return array;
}

1.7 将稀疏数组转为原始的二维数组思路分析

1. 读取稀疏数组的第一行的数据（分别为原始二维数组的行数、列数以及有效数据的个数），并且创建原始的二维数组
2. 在读取稀疏数组后几行的数据，并且赋值给原始的二维数组即可

代码实现：

	/**
     * 将稀疏数组恢复为原始的二维数组
     */
    //1、读取稀疏数组的第一行数据，创建原始二维数组chessArr_2
    chessArr_2 = new int[sparseArr[0][0]][sparseArr[0][1]];
    //2、读取稀疏数组后几行的数据，并赋值给原始二维数组
    int x = 0, y = 0; //x  y 分别代表行 和 列
    for (int i = 1; i < count; i++) {
        x = sparseArr[i][0];
        y = sparseArr[i][1];
        chessArr_2[x][y] = sparseArr[i][2];
    }
    //输出原始二维数组
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            System.out.print(chessArr_2[i][j] + "\t");
        }
        System.out.println();
    }
    saveArray(sparseArr);
    readArray();