数据结构系列——稀疏数组

记录我学习稀疏数组的总结，理清一下云里雾里的思路

稀疏数组定义

为什么要使用稀疏数组呢？根据下面这个类似于棋盘的二维数组来看：
其中有用的数据只有三个，其余的都是默认且无用的0，当无效数据大于有用数据的时候，为了不记录太多没有意义的数据，将二维数组进行压缩，转为普通数组来进行压缩，这样节省了空间避免浪费资源，数据序列化到磁盘，压缩可以提高IO效率

稀疏数组的存储

稀疏数组是怎么存储的呢？它非常有意思，把无意义的数据全部干掉，把得到的数据按照哪一行和哪一列的方式来存储。

把上面那个和棋盘一样的数据压缩成现在的短短几行，但是当有用数据量太多了就不适合用这种方法了，嘿嘿~

int chessArray1[][] = new int[11][11];
        chessArray1[1][8]=81;
        chessArray1[2][1]=6;
        chessArray1[5][3]=99;

让我们来看看下面几行的到底代表了什么？

稀疏数组思路以及代码实现
稀疏数组第一行存储的是原来二维数组的行的长度和列的长度，以及有意义数据的个数

• 11 11 3
  稀疏数组[0][0] = 11;存储二维数组的行
  稀疏数组[0][1] = 11;存储二维数组的列
  稀疏数组[0][2] = 3;存储有意义数据的个数

思路有了，就可以根据思路来实现代码

int sum = 0;//辅助变量，主要用于存储原始二维数组的个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArray1[i][j]!=0){
                    sum++;//通过非0条件抓取个数
                }
            }
        }
        //创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

完成以上代码就实现了稀疏数组第一行存储的数据

让我们再来看这个图片，翻上翻下麻烦：

第一行特定存储原始二维数组的所有行、所有列以及所有有效数据的值
所以我们英才从第二行开始存储有小数据在第几行和第几列，以及存储的值是多少？

• 1 8 81
  稀疏数组[1][0] = 1;存储有意义数据的行
  稀疏数组[1][1] = 8;存储有意义数据的列
  稀疏数组[1][2] = 81;存储的有意义数据

• 2 1 6
  稀疏数组[2][0] = 1;存储有意义数据的行
  稀疏数组[2][1] = 8;存储有意义数据的列
  稀疏数组[2][2] = 81;存储的有意义数据

• 5 3 99
  稀疏数组[3][0] = 1;存储有意义数据的行
  稀疏数组[3][1] = 8;存储有意义数据的列
  稀疏数组[3][2] = 81;存储的有意义数据

思路有了，都一样，数值是往上加，一个个写出来不太现实，就可以用for循环来遍历原始的二维数组，把行、列、有效数据提取出来

 //遍历二维数组，将非0的值存放在sparseArr中
        int count = 0;//记录非0数据
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArray1[i][j]!=0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArray1[i][j];
                }
            }
        }

豁然开朗，哇哈哈哈哈
到现在，稀疏数组已经完成了，输出一下看看有没有错，嘿嘿

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

稀疏数组恢复成二维数组

接下来，压缩过的东西肯定要想办法复原啦
这时候思路理清楚：
稀疏数组–>原始的二维数组

1. 先读取稀疏数组的第一行，根据第一行的数据，创建新的二维数组来存储， chessArr2=int[11][11]

 int chessArr2[][] =new int[sparseArr[0][0]][sparseArr[0][1]];

2. 在读取稀疏数组后几行的数据，并赋给二维数组即可

 for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]= sparseArr[i][2];
        }

总结

1. 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
2. 稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列
   稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值
   第一列：原数组的行数
   第二列：原数组的列数
   第三列：原数组有多少个不为零的值
3. 之后的行记录原数组中不为零（x）的值所在的行数、列数以及 x 的值
   第一列：x 在原数组中的行数
   第二列：x 在原数组中的列数
   第三列：x 的值

今日份收工，祝明天阳光明媚！