1_数据结构与算法

数据结构与算法

1、稀疏数组

1-1. 应用场景

• 1. 用于压缩数据
• 2. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
• 3. 把稀疏数组存盘，并且可以从新恢复原来的二维数组数

1-2. 思路与分析

• 1. 先看是否需要转化为稀疏数组
• 2. 将原来的二维数组转化为固定格式的稀疏数组
• 2. 通过一系列循环遍历将二维数组

1-3. 代码实现

将原有的二维数组转化成稀疏数组，同时再将生成的稀疏数组再转为二维数组

    static void fun1() {
        /**
         * 解决五子棋问题
         * 11X11 个棋盘
         * 1、0-表示没有棋子、1-表示黑色、2-表示蓝色
         */
        int[][] cherryArray1 = new int[11][11];
        cherryArray1[1][2] = 1;
        cherryArray1[2][3] = 2;
        //输出原始二维数组
        for (int[] row : cherryArray1) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
        /**
         * 先遍历二维数组
         * 1、遍历数据非 0 的数量
         */
        int sum = 0;
        for (int[] row : cherryArray1) {
            for (int item : row) {
                if (item != 0) {
                    sum++;
                }
            }
        }
        /**
         * 2、创建对应的稀疏数组，并赋值
         */
        int sparArray[][] = new int[sum + 1][3];
        sparArray[0][0] = 11;
        sparArray[0][1] = 11;
        sparArray[0][2] = sum;
        /**
         * 3、遍历二维数组，将值放入稀疏数组中
         */
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (cherryArray1[i][j] != 0) {
                    count++;
                    sparArray[count][0] = i;
                    sparArray[count][1] = j;
                    sparArray[count][2] = cherryArray1[i][j];

                }
            }
        }
        /**
         * 输出稀疏数组
         */
        for (int[] row : sparArray) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
        /**
         * 将稀疏数组转化为二维数组
         * 1、读取稀疏数组的第一行数据
         */
        int cherryArr2[][] = new int[sparArray[0][0]][sparArray[0][1]];

        for (int i = 1; i < sparArray.length; i++) {
            cherryArr2[sparArray[i][0]][sparArray[i][1]] = sparArray[i][2];
        }
        for (int[] row : cherryArr2) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.printf("\n");
        }
    }

将二维数组转为稀疏数组存到磁盘中，再从磁盘中取出转为二维数组

    /**
     * 将二维数组转为稀疏数组，存在磁盘，并从磁盘取出转为二维数组
     */
    static void fun2() {
        String path = "D:\\Study\\files\\spar.txt";
        /**
         * 解决五子棋问题
         * 11X11 个棋盘
         * 1、0-表示没有棋子、1-表示黑色、2-表示蓝色
         */
        int[][] cherryArray1 = new int[11][11];
        cherryArray1[1][2] = 1;
        cherryArray1[2][3] = 2;
        /**
         * 先遍历二维数组
         * 1、遍历数据非 0 的数量
         */
        int sum = 0;
        for (int[] row : cherryArray1) {
            for (int item : row) {
                if (item != 0) {
                    sum++;
                }
            }
        }
        /**
         * 2、创建对应的稀疏数组，并赋值
         */
        int sparArray[][] = new int[sum + 1][3];
        sparArray[0][0] = 11;
        sparArray[0][1] = 11;
        sparArray[0][2] = sum;
        /**
         * 3、遍历二维数组，将值放入稀疏数组中
         */
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (cherryArray1[i][j] != 0) {
                    count++;
                    sparArray[count][0] = i;
                    sparArray[count][1] = j;
                    sparArray[count][2] = cherryArray1[i][j];
                }
            }
        }

        /**
         * 写入文件中
         */
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        try {
            File file = new File(path);
            if (!file.exists()) {
                file.createNewFile();
            }
            fos = new FileOutputStream(file, false);
            osw = new OutputStreamWriter(fos, "utf-8");
            for (int[] ints : sparArray) {
                for (int anInt : ints) {
                    osw.write(anInt + "\t");
                }
                osw.write("\n");
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                osw.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        /**
         * 读取文件
         */
        FileInputStream fis = null;
        InputStreamReader isr = null;
        try {
            fis = new FileInputStream(path);
            isr = new InputStreamReader(fis, "utf-8");
            StringBuffer sb = new StringBuffer();
            while (isr.ready()) {
                sb.append((char) isr.read());
            }
            System.out.println(sb.toString());
            String newStr = sb.toString();
            String[] nns = newStr.split("\n");
            int sparArray1[][] = new int[nns.length][3];
            for (int i = 0; i < nns.length; i++) {
                String[] tts = nns[i].split("\t");
                for (int j = 0; j < tts.length; j++) {
                    sparArray1[i][j] = Integer.parseInt(tts[j]);
                }
            }
            /**
             * 打印稀疏数组
             */
            for (int[] row : sparArray) {
                for (int item : row) {
                    System.out.printf("%d\t", item);
                }
                System.out.println();
            }
            /**
             * 将稀疏数组转为二维数组
             */
            int cherryArr2[][] = new int[sparArray1[0][0]][sparArray1[0][1]];

            for (int i = 1; i < sparArray1.length; i++) {
                cherryArr2[sparArray[i][0]][sparArray[i][1]] = sparArray[i][2];
            }
            /**
             * 打印二维数组
             */
            for (int[] row : cherryArr2) {
                for (int item : row) {
                    System.out.printf("%d\t", item);
                }
                System.out.println();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                isr.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }