数据结构——稀疏数组（Java实现）

1.1 稀疏数组

1.1.1 实际需求及其介绍

需求：

如果直接使用二维数组的话会有很多没有意义的默认值为0的空间被浪费掉。

• 所以在此引入稀疏数组压缩原先的二维数组，提高空间利用率（牺牲时间来换取空间）

介绍：

稀疏矩阵格式：

	row	col	value
0(原矩阵计数)	全部多少行	全部多少列	全部多少个值
1(原矩阵第一个有效值)	处在原矩阵多少行	处在原矩阵多少列	值是多少
2(原矩阵第二个有效值)	处在原矩阵多少行	处在原矩阵多少列	值多少
…

举例：

1.1.2 实现思路与实现代码

• 二维数组转稀疏数组：
  • 1.遍历原始二维数组，得到有效数据的个数sum
  • 2.根据sum的个数创建稀疏数组 int[sum+1][3]
  • 3.将二维数组的有效数据存储到稀疏数组之中
  • （提高）4.将稀疏数组持久化到磁盘当中
• 稀疏数组转二维数组：
  • 1.读取磁盘文件，得到稀疏数组，根据第一行的数据创建原始的二维数组
  • 2.再读取稀疏数组后面几行的数据，赋值给二维数组即可

实现代码：

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class sparse_Matrix {
    // 读取磁盘内的文件加载稀疏矩阵
    public static int[][] loadMatrix(File file) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        String str = null;
        List<Integer> integerList = new ArrayList<>(); // 将稀疏矩阵的所有数据存储到该列表内
        while ((str = bufferedReader.readLine()) != null){ // 一行行读取文件
            String[] s = str.split(",");
            for(int i=0;i<3;i++){
                integerList.add(Integer.parseInt(s[i]));
            }
        }
        int[][] matrix = new int[integerList.get(0)][integerList.get(1)];
        int index = 3;
        for(int i=0;i<integerList.get(2);i++){
            matrix[integerList.get(index)][integerList.get(index+1)] = integerList.get(index+2);
            index += 3;
        }
        return matrix;
    }

    // 将稀疏矩阵持久化到磁盘内
    public static void saveMatrix(int[][] matrix){
        File file = new File("sparseMatrix.txt");
        FileWriter writer =  null;
        try {
            writer = new FileWriter(file);
            for (int[] ints : matrix) {
                for (int j = 0; j < matrix.length; j++) {
                    writer.write(ints[j]+",");
                }
                writer.write("\n");
            }
            writer.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static int[][] createMatrix(){// 将二维数组转换为稀疏矩阵
        // 创建一个二维矩阵 暂时先写死
        int[][] matrix = new int[11][11];
        matrix[1][2] = 1;
        matrix[2][3] = 2;
        int sum = 0;
        // 遍历输出原二维数组/计算sum值/得到有效数据
        for(int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix.length;j++){
                if(matrix[i][j] != 0){
                    sum += 1; // 计算有效数据个数
                }
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        }
        // 创建稀疏矩阵
        int[][] sparse = new int[sum+1][3];
        sparse[0][0] = matrix.length;
        sparse[0][1] = matrix.length;
        sparse[0][2] = sum;
        int count = 1; // 记录当前是第几个有效数据
        // 再次遍历原二维数组 为稀疏矩阵赋值
        for(int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix.length;j++){
                if(matrix[i][j] != 0){
                    sparse[count][0] = i;
                    sparse[count][1] = j;
                    sparse[count][2] = matrix[i][j];
                    count++;
                }
            }
        }
        // 返回稀疏矩阵
        return sparse;
    }
    public static void main(String[] args) throws IOException {
        int[][] matrix = createMatrix();
        // 遍历输出稀疏矩阵
        for (int[] ints : matrix) {
            for (int j = 0; j < matrix.length; j++) {
                System.out.print(ints[j] + " ");
            }
            System.out.println();
        }
        // 将稀疏矩阵持久化到磁盘
        saveMatrix(matrix);
        // 读取文件得到稀疏矩阵
        int[][] matrixOld = loadMatrix(new File("sparseMatrix.txt"));
        // 遍历得到的稀疏矩阵
        for(int i=0;i<matrixOld.length;i++){
            for(int j=0;j<matrixOld.length;j++){
                System.out.print(matrixOld[i][j]+" ");
            }
            System.out.println("\n");
        }
    }
}