【Java数据结构】普通矩阵与稀疏矩阵的互相转化，稀疏矩阵的物理存储

import java.io.*;

/**
 * @author ZhiYi Li
 * @create 2020/8/24 10:47
 * 普通矩阵转稀疏矩阵，稀疏矩阵转普通矩阵，稀疏矩阵的物理存储
 */
public class SparseArr {
    public static void main(String[] args) {
        //构建一个普通矩阵
        int[][] first = new int[11][12];
        first[2][2]=1;
        first[3][4]=2;
        //输出普通矩阵
        System.out.println("生成的普通稀疏矩阵：");
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(first[i][j]+" ");
            }
            System.out.println();
        }
        //转换为稀疏矩阵
        //遍历普通矩阵查找非0元素
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 10; j++) {
                if(first[i][j]!=0){
                    sum++;
                }
            }
        }
        //构建稀疏矩阵
        int[][] second = new int[sum+1][3];
        //存入第一行
        second[0][0] = first.length;
        second[0][1] = first[0].length;
        second[0][2] = sum;
        //遍历有效节点依次存入稀疏矩阵
        int temp = 0;
        for (int i = 0; i < first.length; i++) {
            for (int j = 0; j < first[0].length; j++) {
                if(first[i][j]!=0){
                    temp++;
                    second[temp][0] = i;
                    second[temp][1] = j;
                    second[temp][2] = first[i][j];
                }
            }
        }
        //输出稀疏矩阵
        System.out.println("转换后的稀疏矩阵如下：");
        for (int[] ints : second) {
            for (int j : ints) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
        //稀疏矩阵转普通矩阵
        System.out.println("稀疏矩阵转普通矩阵：");
        int[][] four =new int[second[0][0]][second[0][1]];
        for (int i = 1; i < second.length; i++) {
            four[second[i][0]][second[i][1]] = second[i][2];
        }
        for(int[] ints:four){
            for (int item : ints){
                System.out.print(item+ " ");
            }
            System.out.println();
        }
        //物理存储稀疏矩阵
        try {
            FileWriter file = new FileWriter("test.data");
            BufferedWriter writer  =new BufferedWriter(file);
            for(int[] data : second){
                for(int item : data){
                    writer.write(item +" ");
                }
                writer.newLine();//文件换行
            }
            writer.close();
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //读取并输出普通矩阵
        System.out.println("物理读取稀疏矩阵如下：");
        try {
            FileReader fileReader = new FileReader("test.data");
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String str = bufferedReader.readLine();
            String[] s = str.split(" ");
            int[][] third = new int[Integer.parseInt(s[0])][Integer.parseInt(s[1])];
            while ((str = bufferedReader.readLine())!=null){
                String[] s1 = str.split(" ");
                third[Integer.parseInt(s1[0])][Integer.parseInt(s1[1])] = Integer.parseInt(s1[2]);
            }
            for (int[] ints : third) {
                for (int j : ints) {
                    System.out.print(j + " ");
                }
                System.out.println();
            }
            bufferedReader.close();
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}