稀疏数组之数据结构与算法

1、稀疏数组是什么

• 在数组中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该数组为稀疏矩阵；
• 与之相反，若非0元素数目占大多数时，则称该矩阵为稠密数组。定义非零元素的总数比上数组所有元素的总数为数组的稠密度。

2、作用

稀疏矩阵几乎产生于所有的大型科学工程计算领域，包括计算流体力学、统计物理、电路模拟、图像处理、纳米材料计算等。

3、思路

3.1、二维数组转换成稀疏数组

	1、创建二维数组
	2、遍历有效个数
	3、根据有效个数创建稀疏数组

3.2、稀疏数组转换为二维数组

• 稀疏数组的 第一行第一列 为二维数组的行数

• 稀疏数组的 第一行第二列 为二维数组的列数

• 稀疏数组的 第一行第三列 为二维数组的有效值个数

• 从第二行开始就表示值的下标行和列，值为多少

  1、根据稀疏数组第一行的数据还原二维数组大小
  2、根据第一行后的数据还原数据位置和数据的值
  

4、代码实现

public class DataSpares{
    public static void main(String[] args) {
        //创建棋盘,1表示黑棋，2表示白棋
        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;

        System.out.println("======棋盘遍历输出：======");

        //循环遍历一次棋盘
        for(int[] row:chessArr){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        //遍历棋盘获取棋盘中的有效棋子
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr[i][j]!=0){
                    sum++;
                }
            }
        }

        //利用获取到的有效棋子个数，创建稀疏数组
        int parseArr[][] = new int[sum+1][3];
        parseArr[0][0] = 11;
        parseArr[0][1] = 11;
        parseArr[0][2] = sum;

        //遍历数组把有效值取出
        int count = 0;//控制稀疏数组中棋子行数
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr[i][j]!=0){
                    count++;
                    parseArr[count][0] = i;
                    parseArr[count][1] = j;
                    parseArr[count][2] = chessArr[i][j];
                }
            }
        }

        System.out.println("======稀疏数组输出：======");

        //遍历稀疏数组
        for(int[] row:parseArr){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }


        System.out.println("======稀疏数组恢复：======");
        int[][] arr2 = new int[parseArr[0][0]][parseArr[0][1]];

        for(int i =1;i<=parseArr[0][2];i++){
            arr2[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];
        }

        //遍历数组
        for(int[] row:arr2){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

    }
}

输出结果：

5、输出磁盘

public class DataSpares{
	//main方法中执行方法
    public static void main(String[] args){
		System.out.println("======输出磁盘:======");
        try{
            sparseArrayTo(parseArr);
            System.out.println("输出磁盘成功");
        }catch(Exception e){
            e.printStackTrace();
        }
    }

	//把稀疏数组写入到txt文件中
    public static void sparseArrayTo(int[][] sparseArray) throws Exception{
        File file = new File("sparseFile.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        FileWriter writer = new FileWriter(file);
        for(int i = 0;i < sparseArray.length;i++ ){
            for(int j = 0;j < 3;j++){
                writer.write(sparseArray[i][j]);
            }
        }
        writer.flush();
        writer.close();
    }
}

6、磁盘读取

public class DataSpares{
	//main方法中执行方法
    public static void main(String[] args){
		System.out.println("======从磁盘读取:======");
        int[][] sparseArr2 = null;
        try{
            sparseArr2 = sparseArrayFromIo(count+1);
        }catch(Exception e){
            e.printStackTrace();
        }

        for(int[] row:sparseArr2){
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
     	}
    }

	//从txt文件中读取稀疏数组
    public static int[][] sparseArrayFromIo(int lineNums) throws Exception {
        FileReader reader = new FileReader("sparseFile.txt");
        int getNum = 0;
        int[][] sparseArray = new int[lineNums][3];
        for(int i = 0;i < lineNums;i++) {
            for (int j = 0; j < 3; j++) {
                getNum = reader.read();
                sparseArray[i][j] = getNum;
            }
        }
        return sparseArray;
    }
}

最终效果截图：