526互联

稀疏数组(sparseArray)

发布时间 2023-11-22 10:43:57作者: MGLblog

稀疏数组

1.二维数组转成稀疏数组

//        将二维数组转成稀疏数组
//        1.得到非零个数sum
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0)
                    sum++;
            }
        }
//        2.创建稀疏数组行数sum+1，列数固定，行数、列数和有效值
        int[][] sparsArr = new int[sum + 1][3];
//        第一行记录二维数组的行数、列数和有效值个数
        sparsArr[0][0] = 11;
        sparsArr[0][1] = 11;
        sparsArr[0][2] = sum;
//        用于记录是第几个非零数据
        int count = 0;
//        遍历二维数组，将非零值存放到sparseArr中
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0) {
                    count++;
                    sparsArr[count][0] = i;
                    sparsArr[count][1] = j;
                    sparsArr[count][2] = chessArray[i][j];
                }

            }
        }
        System.out.println("稀疏数组为~~~~");
        for (int i = 0; i < sparsArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparsArr[i][0], sparsArr[i][1], sparsArr[i][2]);
        }

2.将稀疏数组保存的本地

public static void saveSparseArrToFile(int[][] sparse, String filepath) throws Exception {
//        写入文件
        FileOutputStream fos = new FileOutputStream(filepath);
        DataOutputStream dos = new DataOutputStream(fos);
        for (int[] row : sparse) {
            for (int data : row) {
                dos.writeInt(data);
            }
        }
        if (dos != null)
            dos.close();
        if (fos != null)
            fos.close();
    }

3.将本地文件数据读取到稀疏数组中

public static int[][] getSparseArrFromFile(String filePath) throws Exception {
        int[][] arr = {};
        FileInputStream fis = new FileInputStream(filePath);
        DataInputStream dis = new DataInputStream(fis);
//        读取第一行数据
        int row = dis.readInt();
        int col = dis.readInt();
        int count = dis.readInt();
//        第一行代表几行几列几个非零数
        arr = new int[row][col];
//        根据count给arr赋值
        for (int i = 0; i < count; i++) {
            arr[dis.readInt()][dis.readInt()] = dis.readInt();

        }
        if (dis != null)
            dis.close();
        if (fis != null)
            fis.close();
        return arr;
    }

4.将稀疏数组转成原始的二维数组

//        将稀疏数组转成原始的二维数组
//        读取第一行的，将第一行的数据，创建原始的数组
        int[][] chessArray2 = new int[sparsArr[0][0]][sparsArr[0][1]];
//        读取稀疏数组后几行的数据(从第二行开始)，并赋值给原始的二维数组
        for (int i = 1; i < sparsArr.length; i++) {
            chessArray2[sparsArr[i][0]][sparsArr[i][1]] = sparsArr[i][2];
        }
//        输出恢复后的二维数组
        System.out.println();
        System.out.println("输出恢复后的二维数组~~");
        for (int[] row : chessArray2) {
            for (int data : row) {
                System.out.print(data + " ");
            }
            System.out.println();
        }
    }

5.测试的代码

/**
 * @author 缪广亮
 * @version 1.0
 */
public class SparseArray01 {
    public static void main(String[] args) throws Exception {
//        将一个11x11的二维数组
        int[][] chessArray = new int[11][11];
//        0：无子；1：黑子；2：蓝子
        chessArray[1][2] = 1;
        chessArray[2][3] = 2;
        for (int[] row : chessArray) {
            for (int data : row) {
                System.out.print(data + " ");
            }
            System.out.println();
        }
//        将二维数组转成稀疏数组
//        1.得到非零个数sum
        int sum = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0)
                    sum++;
            }
        }
//        2.创建稀疏数组行数sum+1，列数固定，行数、列数和有效值
        int[][] sparsArr = new int[sum + 1][3];
//        第一行记录二维数组的行数、列数和有效值个数
        sparsArr[0][0] = 11;
        sparsArr[0][1] = 11;
        sparsArr[0][2] = sum;
//        用于记录是第几个非零数据
        int count = 0;
//        遍历二维数组，将非零值存放到sparseArr中
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray.length; j++) {
                if (chessArray[i][j] != 0) {
                    count++;
                    sparsArr[count][0] = i;
                    sparsArr[count][1] = j;
                    sparsArr[count][2] = chessArray[i][j];
                }

            }
        }
        System.out.println("稀疏数组为~~~~");
        for (int i = 0; i < sparsArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparsArr[i][0], sparsArr[i][1], sparsArr[i][2]);
        }
//        //4.将稀疏数组保存到文件中
//        String filePath = "E:\\sparseArr.txt";
//        saveSparseArrToFile(sparsArr, filePath);
//
//        //5.将文件数据读取到稀疏数组中
//        int[][] fileSparseArr = getSparseArrFromFile(filePath);
//        //打印读取的稀疏数组
//        System.out.println("打印读取转换后的二维数组：\n----------------------------");
//        for (int[] row : fileSparseArr) {
//            for (int data : row) {
//                System.out.print(data+" ");
//            }
//            System.out.println();
//        }
//        将稀疏数组转成原始的二维数组
//        读取第一行的，将第一行的数据，创建原始的数组
        int[][] chessArray2 = new int[sparsArr[0][0]][sparsArr[0][1]];
//        读取稀疏数组后几行的数据(从第二行开始)，并赋值给原始的二维数组
        for (int i = 1; i < sparsArr.length; i++) {
            chessArray2[sparsArr[i][0]][sparsArr[i][1]] = sparsArr[i][2];
        }
//        输出恢复后的二维数组
        System.out.println();
        System.out.println("输出恢复后的二维数组~~");
        for (int[] row : chessArray2) {
            for (int data : row) {
                System.out.print(data + " ");
            }
            System.out.println();
        }
    }

    public static void saveSparseArrToFile(int[][] sparse, String filepath) throws Exception {
//        写入文件
        FileOutputStream fos = new FileOutputStream(filepath);
        DataOutputStream dos = new DataOutputStream(fos);
        for (int[] row : sparse) {
            for (int data : row) {
                dos.writeInt(data);
            }
        }
        if (dos != null)
            dos.close();
        if (fos != null)
            fos.close();
    }

    public static int[][] getSparseArrFromFile(String filePath) throws Exception {
        int[][] arr = {};
        FileInputStream fis = new FileInputStream(filePath);
        DataInputStream dis = new DataInputStream(fis);
//        读取第一行数据
        int row = dis.readInt();
        int col = dis.readInt();
        int count = dis.readInt();
//        第一行代表几行几列几个非零数
        arr = new int[row][col];
//        根据count给arr赋值
        for (int i = 0; i < count; i++) {
            arr[dis.readInt()][dis.readInt()] = dis.readInt();

        }
        if (dis != null)
            dis.close();
        if (fis != null)
            fis.close();
        return arr;
    }
}