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

稀疏sparsearray数组
先看一个实际的需求: 编写的五子棋程序中，有存盘退出和续上盘的功能。

分析问题:
因为该二维数组的很多值是默认值0, 因此记录了很多没有意义的数据.->稀疏数组。

稀疏数组

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

稀疏数组的处理方法是:
记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

应用实例

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

/**
 * 功能描述: 稀疏数组-相关练习
 *
 * @author lunaw-
 * @version 1.0
 * @date 2023/12/7 21:07
 */
public class SparseArrayDemo {
    public static void main(String[] args) {
        //以五子棋程序为例，定义一个普通二维数组
        int[][] commonArray = new int[11][11];
        commonArray[1][2] = 1;
        commonArray[2][3] = 2;

        //首先打印出原始数组
        System.out.println("---------------------------打印原始二维数组:---------------------------");
        for (int[] array : commonArray) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + "\t");
            }
            System.out.println();
        }


        /**
         *  二维数组转稀疏数组
         */

        //先计算出二维数组的有效数据个数
        int size = 0;
        for (int[] array : commonArray) {
            for (int i = 0; i < array.length; i++) {
                if (array[i] != 0) {
                    size++;
                }
            }
        }
        //定义一个稀疏数组
        int[][] sparseArray = new int[size + 1][3];
        sparseArray[0][0] = commonArray.length;
        sparseArray[0][1] = commonArray[0].length;
        sparseArray[0][2] = size;
        int count = 0;
        for (int i = 0; i < commonArray.length; i++) {
            for (int j = 0; j < commonArray[i].length; j++) {
                if (commonArray[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = commonArray[i][j];
                }
            }
        }
        System.out.println("---------------------------打印转换后的稀疏数组:---------------------------");
        for (int[] array : sparseArray) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + "\t");
            }
            System.out.println();
        }

        /**
         *  稀疏数组转二维数组
         */
         
        int[][] mySparseArray = new int[3][3];
        mySparseArray[0][0] = 11;
        mySparseArray[0][1] = 11;
        mySparseArray[0][2] = 2;
        mySparseArray[1][0] = 1;
        mySparseArray[1][1] = 2;
        mySparseArray[1][2] = 1;
        mySparseArray[2][0] = 2;
        mySparseArray[2][1] = 3;
        mySparseArray[2][2] = 2;

        int[][] myArray = new int[mySparseArray[0][0]][mySparseArray[0][1]];
        for (int i = 1; i < mySparseArray.length; i++) {
            myArray[mySparseArray[i][0]][mySparseArray[i][1]] = mySparseArray[i][2];
        }
        System.out.println("---------------------------打印转换回来的普通二维数组:---------------------------");
        for (int[] array : myArray) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + "\t");
            }
            System.out.println();
        }
    }

}

课后练习

1. 在前面的基础上，将稀疏数组保存到磁盘上，比如 map.data
2. 恢复原来的数组时，读取map.data 进行恢复

/**
 * 功能描述: 稀疏数组-相关练习
 *
 * @author lunaw-
 * @version 1.0
 * @date 2023/12/7 21:07
 */
public class SparseArrayDemo {
    public static void main(String[] args) {
        int[][] sparseArray = new int[3][3];
        sparseArray [0][0] = 11;
        sparseArray [0][1] = 11;
        sparseArray [0][2] = 2;
        sparseArray [1][0] = 1;
        sparseArray [1][1] = 2;
        sparseArray [1][2] = 1;
        sparseArray [2][0] = 2;
        sparseArray [2][1] = 3;
        sparseArray [2][2] = 2;

        int[][] newSparseArray = new int[3][3];
        //写入map.data
        writeToFile(sparseArray, "D:\\workspace_java\\Helloworld\\src\\main\\resources\\map.data");
        //读取二维数组
        readFile(newSparseArray, "D:\\workspace_java\\Helloworld\\src\\main\\resources\\map.data");
        System.out.println("---------------------------打印从磁盘上读取的稀疏数组:---------------------------");
        for (int[] array : newSparseArray) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + "\t");
            }
            System.out.println();
        }
    }


    /**
     * 将稀疏数组写入到指定文件夹
     *
     * @param sparseArray 稀疏数组
     * @param fileName    文件位置
     */
    public static void writeToFile(int[][] sparseArray, String fileName) {
        File file = new File(fileName);
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileWriter = new FileWriter(file);
            bufferedWriter = new BufferedWriter(fileWriter);
            for (int i = 0; i < sparseArray.length; i++) {
                bufferedWriter.write(Arrays.toString(sparseArray[i]).replace("[", "").replace("]", ""));
                bufferedWriter.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }

    /**
     * 将稀疏数组从磁盘中读出
     *
     * @param sparseArray 稀疏数组
     * @param fileName    文件位置
     * @return 稀疏数组
     */
    public static int[][] readFile(int sparseArray[][], String fileName) {
        File file = new File(fileName);
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        try {
            fileReader = new FileReader(file);
            bufferedReader = new BufferedReader(fileReader);
            String line = null;
            int row = 0;
            while ((line = bufferedReader.readLine()) != null) {
                String[] split = line.split(",");
                for (int i = 0; i < split.length; i++) {
                    sparseArray[row][i] = Integer.parseInt(split[i].trim());
                }
                row++;

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return sparseArray;
    }

}