稀疏数组【矩阵】

稀疏数组

 

1. 第一行：记录原始数组一共有几行几列，几个不同的值
2. 余下行：把具有不同值的元素的行列及值记录在一个数组中，从而缩小程序的规模

 二维数组  转  稀疏数组的思路

1.遍历 原始二维数组 ，得到有效数据个数 sum

2.根据sum 创建 稀疏数组 sparseArr int[sum+1][3]   3一定不变

3.将二维数组有效数据存入到稀疏数组中

稀疏数组转原始二维数组思路 

1. 先读取稀疏数组的第一行前两个数据 创建原始二维数组

2.读取稀疏数组后几行的数据 并赋值给原始数组即可

public class T1 {
    public static void main(String[] args) {
        //将二维数组压缩成稀疏数组
        //1.创建二维数组
        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        int sum = 0;
        //2.得到有效数据个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++)
                if (chessArr[i][j] != 0)
                    sum++;
        }
        //3.创建稀疏数组
        int spareArr[][] = new int[sum+1][3];
        spareArr[0][0] = 11;
        spareArr[0][1] = 11;
        spareArr[0][2] = sum;
        //4.赋值
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                    spareArr[count][0] = i ;
                    spareArr[count][1] = j ;
                    spareArr[count][2] = chessArr[i][j] ;
                }
            }
        }
        System.out.println("输出稀疏数组");
        for (int i=0;i<spareArr.length;i++)
            System.out.printf("%d\t%d\t%d\t\n",spareArr[i][0],spareArr[i][1],spareArr[i][2]);

        System.out.println("==============");
        //稀疏数组转为二维数组
        //1.读取稀疏数组的第一行前两个数据，然后创建新二维数组
        int chessArr1[][] = new int[spareArr[0][0]][spareArr[0][1]];
        //2.遍历稀疏数组第二行置后面，然后赋值给二维数组
        for (int i = 1;i< spareArr.length;i++){
            chessArr1[spareArr[i][0]][spareArr[i][1]] = spareArr[i][2];
        }
        //3.输出二维数组
        for (int[] row : chessArr1){
            for (int data :row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

将稀疏数组保存到磁盘上，并恢复 【新增功能】

保存稀疏数组

//读取到磁盘中
        //获取文件对象
        File file = new File("E:\\map.data");
        //文件写入流
        FileWriter writer = new FileWriter(file);
        //遍历数组，写入文件
        for (int[] sparse:sparseArr) {
            for (int s:sparse) {
                writer.write(s+"\t");
            }
            writer.write("\n");
        }
        writer.close();

恢复稀疏数组

 //从磁盘中读取数据
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line = "";
        int[][] chessArr2 = null;
        int row = 0;

        //循环读取文件的每一行数据
        while ((line=reader.readLine())!=null){
            //按tab位切割成字符串数组，再转为int数组
            String[] temp = line.split("\t");
            int[] ints = new int[temp.length];
            for (int i = 0; i < ints.length; i++) {
                ints[i] = Integer.parseInt(temp[i]);
            }
            row++;
            //文件第一行，即稀疏数组的第一行数组，为原始数组的长宽数量
            if (row==1){
                chessArr2 = new int[ints[0]][ints[1]];
            }else{
                //余下添加即可，没有赋值的地方，数组会初始化为0
                chessArr2[ints[0]][ints[1]] = ints[2];
            }
        }
        reader.close();
    }