稀疏数组

目录

• 定义
• 存储方式
  • 思路
  • 程序描述

定义

看下面的二维数组：

  0  0  0  0  0  0  0  0  0
  0  0  0  2  0  0  0  0  0
  0  0  0  0  0  0  0  0  0
  0  0  8  0  0  0  6  0  0
  0  0  0  0  0  0  0  0  0
  0 11  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0
  0  0  0  0  2  0  0  0  0
  0  0  0  0  0  0  34 0  0

可以发现，该二维数组的值大多数都为0，有效值就只有几个，且分布不均；那就会存在一个问题，这种数组有大量的无用数据，会占很大的存储空间，为了节省存储空间，就要思考怎么样来存储这种数组。

百度百科对稀疏矩阵的定义：在矩阵中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵；与之相反，若非0元素数目占大多数时，则称该矩阵为稠密矩阵。
（矩阵和数组差不多）

所以如果一个二维数组的大多数值都为0，那么就称该数组为稀疏数组。

存储方式

思路

存储：

• 我们可以统计出稀疏数组的有效值个数，创建一个n行3列的新数组来存储该稀疏数组；
• 新数组的第一行的第一、二列的值分别表示原稀疏数组的行数和列数，第三列表示有效值个数；
• 新数组从第二行起，第一、二列的值表示有效值在原稀疏数组中的下标（下标从0开始），第三列的值表示原稀疏数组中的有效值。

如上面的稀疏数组可以转化为下面的数组：

  9  9  6          //原稀疏数组有9行9列，共6个有效值
  1  3  2          //第一个有效值的下标为[1][3]，值为2，以此类推······
  3  2  8
  5  1  11
  7  4  2
  8  6  34

还原：

• 读取存储数组第一行的第一、二列的值，作为还原原稀疏数组的行数和列数；
• 从存储数组的第二行开始，读取第一、二列的值作为还原原稀疏数组有效值的下标，第三列作为有效值。

程序描述

下面使用java语言对稀疏数组的存储和还原作描述：

/**
 * @Description:
 * @Author: 小强
 * @Date: 2021/4/18
 * @Tools: IntelliJ IDEA
 * @Remember: Be professional every day
 **/
public class SparseArray {
    public static void main(String[] args) {
        /*
        定义一个 稀疏数组，随机赋值
         */
        int[][] array1 = new int[10][10];
        array1[3][5] = 2;
        array1[4][1] = 13;
        array1[7][8] = 9;
        array1[0][8] = 39;
        array1[6][4] = 27;

        /*
        遍历原始数组并统计有效值的个数
         */
        int sum = 0;
        System.out.println("原始稀疏数组：");
        for(int row[]:array1){
            for(int col:row){
                System.out.print(col+"\t");
                if (col != 0)
                    sum++;
            }
            System.out.println();
        }




        /*
        定义一个新数组存储稀疏数组
         */
        int[][] array2 = new int[sum+1][3];
        array2[0][0]=array1.length;
        array2[0][1]=array1[0].length;
        array2[0][2]=sum;

        int count = 0;  //作用是标识第几个非0数
        /*
        为稀疏数组赋值
         */
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[0].length ; j++) {
                if (array1[i][j] != 0){
                    array2[++count][0]=i;       //说明有非0数，count+1
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }

        System.out.println("转化为新的存储数组：");
        for(int row[]:array2){
            for(int col:row){
                System.out.print(col+"\t");
            }
            System.out.println();
        }

        /*
        创建新数组array3，并读取array2中的数据为array3赋值
         */
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("还原原稀疏数组：");
        for (int row[]:array3) {
            for (int col:row) {
                System.out.print(col+"\t");
            }
            System.out.println();
        }

    }
}

运行结果：