稀疏数组（java详解+实例）

前言：

        稀疏数组是一种用来压缩数据量的数据结构，一般用于一些特殊的数组，一个数组中大部分元素为0，或者为同一数值时，可以使用稀疏数组来保存该数组，以节省数据量。简而言之，就是记录特殊值，然后剩下大量重复的数据可以消减。通过学习稀疏数组，在处理某些问题的时候可以节省存储空间并加快计算速度。

正文：

稀疏数组的处理方式是：

• 记录数组一共有几行几列，有多少个不同值

• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

比如说：

0 0 0 0 0 0 0 0

0 4 0 0 0 0 6 0

0 0 9 0 7 0 0 0

0 5 0 1 0 0 0 0

这么一个二维数组，化成稀疏数组可以表示为：

行	列	值
8	4	6
1	1	4
1	6	6
2	2	9
2	4	7
3	1	5
3	3	1

关于这个表格有几个注意事项：

1. 表格的第一行，是表示有多少行  多少列   有多少个非零元素（有效值）
2. 数组是从0开始的
3. 稀疏数组的行数等于有效值+1，列数固定都为3

代码实现如下：（该代码是将数组化作一个棋盘，参考了狂神的视频）

Ps（我知道这段代码很长，但是相信我！不复杂，我将每个步骤分成一个个的小块，跟着注释一步步看下来，结合上面对稀疏数组的一段解释，你就能知道我这一大串代码在表达什么了~）

import java.util.Arrays;

//稀疏数组：用来减少数据量的
public class SparseArray {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11  0：没有棋子，1：黑棋  2：白棋
        int [][]array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("输出原始的数组:");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("====================");


        //转换成稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数"+sum);
        //2、创建一个稀疏数组的数组
        //因为头部还有一行，所以行数是有效值的个数+1
        int [][]array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;


        //遍历初始的二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }


        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }


        //还原数组
        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("=======================");
        //打印还原的数组
        System.out.println("输出还原后的数组：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


        //验证两个数组是否相等，可用Arrays工具类
        int flag = 0;
        for (int i = 0; i < array1.length; i++) {
            if (!Arrays.equals(array1[i],array3[i])){
                flag++;
            }
        }
        if (flag==0){
            System.out.println("初始数组和还原后的数组相等");
        }
    }
}

总结：

创建稀疏数组的几个步骤：

1. 首先确定要转换的数组具有多少行多少列

2. 通过循环遍历得出数组中有几个有效值

3. 创建稀疏数组，行是有效值的个数，列是3

4. 确定稀疏数组的第一行表头：行 列 值

5. 通过遍历原始数组，将有效值的i和j赋值给稀疏数组

还原稀疏数组步骤：

1. 创建一个新的数组，其行和列等于稀疏数组表头的行和列

2. 通过遍历稀疏数组，将对应数值赋值给新的数组

3. 最后可以验证一下原始的数组和还原后的数组是否相等

        如果有人看到了这里，真的很感谢，如果书写的有什么谬误，还请大佬指正，对稀疏数组有什么问题也可以私信我，我们可以一起交流学习！在我看来，只有经过不断讨论，才能碰撞出更尽善尽美的想法和多元的思考角度🌹🌹