稀疏数组

package cn.tk.message;

import java.io.*;

public class SparseArray {


    public static void main(String[] args) {
        int[][] arr;//二维数组
        int[][] sparseToArrs;//文件读取的稀疏数组还原二维数组
        int[][] sparseArr;//二数组转的稀疏
        int[][] fileSparseArr;//文件读取的稀疏数组
        //创建二维
        arr = creatArr();
        //遍历二维数组
        System.out.println("创建的二维数组：");
        forArr(arr);
        //二维数组转稀疏数组
        sparseArr = arrToSparseArr(arr);
        System.out.println("\n创建的二维数组转稀疏数组：");
        forArr(sparseArr);
        //存稀疏数组盘
//        saveSparse(sparseArr);
        // 文件读取稀疏数组
//        fileSparseArr = fileReadSparse();
//        System.out.println("\n文件读取的稀疏数组：");
//        forArr(fileSparseArr);

        //文件读取的稀疏数组转二维数组
        sparseToArrs = sparseToArr(sparseArr);
        System.out.println("\n文件读取的稀疏数组还原二维数组：");
        forArr(sparseToArrs);
    }

    /**
     * 文件读取稀疏数组
     *
     * @return spare 稀疏数组
     */

    private static int[][] fileReadSparse() {
        int[][] spare = null;
        String path = "d:/aa/data.demo";//读取路径
        try {
            //第一次读取获得行数创建 [?][3]spare的稀疏数组
            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(path), "utf-8"));
            int row = 0;//行数
            String line;
            //一行一行读取
            while ((line = in.readLine()) != null) {
                row++;
            }
            //创建稀疏数组spare
            spare = new int[row][3];

            //第二读取给稀疏数组存值[?][3]spare ?=row
            BufferedReader againIn = new BufferedReader(new InputStreamReader(new FileInputStream("d:/aa/data.demo"), "utf-8"));
            int r = 0;//稀疏数组行下标
            while ((line = againIn.readLine()) != null) {
                //读一行存入稀疏数组一行
                String[] arr = line.split(" ");//空格分隔出一个数组
                for (int i = 0; i < arr.length; i++) {
                    spare[r][i] = Integer.parseInt(arr[i]);
                }
                r++;
            }
            in.close();
//            //输出读取的数组
//            System.out.println("输出读取的数组");
//            forArr(spare);
            System.out.println("读取稀疏数组成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return spare;
    }

    /**
     * 稀疏数组存盘
     *
     * @param sparseArr 存盘的稀疏数组
     */
    private static void saveSparse(int[][] sparseArr) {
        String path = "d:/aa/data.demo";//存放路径
        try {
            PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(path), "utf-8"));
            for (int i = 0; i < sparseArr.length; i++) {
                for (int j = 0; j < sparseArr[1].length; j++) {
                    out.print(sparseArr[i][j] + " ");
//                    System.out.print(sparseArr[i][j]);
                }
                out.println();
            }
            System.out.println("稀疏数组存盘成功！！！");
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 稀疏数组转二维数组
     *
     * @param sprseArr
     * @return
     */
    private static int[][] sparseToArr(int[][] sprseArr) {
        /* [][]sparse   row col value    稀疏数组第一行
                        11  5   2
                        ·······
                        sparse[0][0] -- 11 二维数组的行
                        sparse[0][1] -- 5  二维数组的列
                        sparse[0][2]  -- 2  二维数组有效值

                        sparse[1+][0] -- ？ 二维数组有效数据的行
                        sparse[1+][1] -- ？ 二维数组有效数据的列
                        sparse[1+][2]  -- ？ 二维数组有效数据值

         */
        //获取稀疏数组（0,0）=row （0,1）=col 创建二维数组[row][col]arr
        int row = sprseArr[0][0];
        int col = sprseArr[0][1];
        int[][] arr = new int[row][col];

        //读取第二行后的数据存入二维数组
        for (int i = 1; i < sprseArr.length; i++) {
            arr[sprseArr[i][0]][sprseArr[i][1]] = sprseArr[i][2];
        }
        return arr;
    }

    /**
     * 二维数组转稀疏数组
     *
     * @param arr
     * @return
     */
    private static int[][] arrToSparseArr(int[][] arr) {
        //1遍历二维数组得到有效数据个数
        int sum = forArr(arr, 1);

        //定义稀疏数组
        int[][] sparseArr = new int[sum + 1][3];

        //2给稀疏数组第一行赋值 [0][0]二维数组行 [0][1]列 [0][3]有效值个数
        sparseArr[0][0] = arr.length;
        sparseArr[0][1] = arr[0].length;
        sparseArr[0][2] = sum;

        //遍历二维数组把有效值放在稀疏数组中
        sparseArr = forArr(arr, sparseArr);

        return sparseArr;
    }

    /**
     * 遍历二维数组中的有效值给稀疏数组
     *
     * @param arr       二维数组
     * @param sparseArr 稀疏数组
     * @return
     */
    private static int[][] forArr(int[][] arr, int[][] sparseArr) {
        int n = 1;//稀疏数组存放从第二行开始
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    sparseArr[n][0] = i;
                    sparseArr[n][1] = j;
                    sparseArr[n][2] = arr[i][j];
                    n++;
                }
            }
        }
        return sparseArr;
    }
    /**
     * 遍历输出二维数组
     *
     * @param arr 二维数组
     */
    private static int forArr(int[][] arr) {
        for (int[] row : arr
        ) {
            for (int number :
                    row) {
                System.out.print(number + " ");
            }
            System.out.println();
        }
        return 0;
    }

    /**
     * 遍历返回二维数组的有效个数
     *
     * @param arr
     * @param notNumber 没有意义的值
     * @return
     */
    private static int forArr(int[][] arr, int notNumber) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    sum++;
                }
            }
        }
        return sum;
    }

    /**
     * 创建11*5 （1,2）=1（2,3）=2的二维数组
     *
     * @return arr 二维数组
     */
    private static int[][] creatArr() {
        int row = 11;//二维数组的行
        int col = 5;//二维数组的里列
        int[][] arr = new int[row][col];
        //设置稀疏数组有效个数
        arr[1][2] = 11;
        arr[2][3] = 2;
        arr[3][4] = 1;
        return arr;
    }
}