数据结构与算法：稀疏数组Java版

什么是稀疏数组

稀疏数组是一种特殊的数据结构，它仅在数组中保存了有效的数据元素，忽略掉了大部分未被使用或被零值占据的元素，从而节省了内存空间。

在稀疏数组中，只有非零元素会被保存，这些元素在原数组中的位置和值保持不变。稀疏数组通常用于存储大规模但只有少量非零元素的数据集，例如稀疏矩阵等。

总结一下：

1. 是一种特殊的数据结构
2. 只保存有效的数据元素
3. 节省了内存空间

代码说明

1. 将普通的二维数组压缩成为稀疏数组
2. 将稀疏数组再转换为普通的二维数组
3. 将稀疏数组通过IO流存入到文件中
4. 从文件中读取到稀疏数组

package com.haimeng.sparsearray;

import java.io.*;

public class SparseArray {

    public static void main(String[] args) throws Exception {
        // 创建一个原始的二维数组 	11*11
        // 0:表示没有棋子,1:表示黑子,2:表示白子

        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;

        //输出原始的二维数组
        System.out.println("原始的二维数组：");
        for(int[] row : chessArr1) {
            for(int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        //将二维数组转换为稀疏数组
        //1.先遍历二维数组	得到非0数据的个数
        int sum = 0;
        for(int i = 0; i < 11; i++) {
            for(int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
            }
        }

        //2.创建对应的稀疏数组
        int sparseArrp[][] = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArrp[0][0] = 11;
        sparseArrp[0][1] = 11;
        sparseArrp[0][2] = sum;

        //遍历二维数组，将非0的值存放到sparseArrp中
        int count = 0; //count 用于计算是第几个非0数据
        for(int i = 0; i < 11; i++) {
            for(int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArrp[count][0] = i;
                    sparseArrp[count][1] = j;
                    sparseArrp[count][2] = chessArr1[i][j];
                }
            }
        }

        //输出稀疏数组的形式
        System.out.println();
        System.out.println("得到稀疏数组为：");
        for(int i = 0; i <sparseArrp.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArrp[i][0],sparseArrp[i][1],sparseArrp[i][2]);
        }
        System.out.println();

        //将稀疏数组---》恢复成原始的二维数组
		/*
		 * 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
		   2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
		 */

        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int chessArr2[][] = new int[sparseArrp[0][0]][sparseArrp[0][1]];


        //2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可.
        for(int i = 1;i<sparseArrp.length;i++) {
            chessArr2[sparseArrp[i][0]][sparseArrp[i][1]] = sparseArrp[i][2];

        }



        //恢复后的二维数组
        System.out.println();

        System.out.println("恢复后的二维数组:");

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



        //--------------------------------------------------------------
        //将稀疏数组 sparseArrp 存入到文件中去

        //覆盖管道
        Writer fw = new FileWriter("src/com/haimeng/sparsearray/test.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        for (int[] row : sparseArrp) {
            for (int num : row) {
                bw.write(num + " ");
            }
            bw.newLine();
        }
        bw.close();


        //将文件中的稀疏数组读取出来,并打印到控制台
        Reader fr = new FileReader("src/com/haimeng/sparsearray/test.txt");
        BufferedReader br = new BufferedReader(fr);

        String line;
        int row = 0;    //用来表示行数
        int[][] array = new int[3][3]; //用来保存从文件中读取出来的稀疏数组
        while ((line = br.readLine()) != null){

            String[] numbers = line.split(" ");
            for (int i = 0; i < numbers.length; i++) {
                array[row][i] = Integer.parseInt(numbers[i]);
            }
            row++;
        }

        //遍历稀疏数组---array
        System.out.println("从文件中读取出来的稀疏数组是：");
        for(int[] row2 : array) {
            for(int data : row2) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

    }

}

运行结果