稀疏数组

1.什么是稀疏数组？

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组。

下面蓝色的就是普通的二维数组转换成稀疏数组的形式

2.为什么要用稀疏数组？

当二维数组中的很多值的默认值为0，因此也记录了很多没有意义的数据。
所以当一个数组中大部分元素为零或同一值时，可以使用稀疏数组来保存该数组。
把具有不同值的元素及值记录在一个小规模的数组中，从而缩小程序的规模。

3.关于稀疏数组的解释：

稀疏数组：也是一个特殊的数组罢了，只不过是对记录着一个二维数组的位置，和对应的位置的值。默认值就不保存了。

4.稀疏数组的存储规则：

稀疏数组的第0行 保存着原二维数组基本信息，既 行数，列数 ，有效值的个数。
从第1行开始，就记录着每个特殊值的行下标，列下标，有效值的值。
以此类推！

5.如何用去实现稀疏数组？

1. 二维数组转稀疏数组的思路 遍历原始二维数组，判断是不是默认值，不是就保存下来，然后得到有效数据的个数sum。
2. 根据sum就可以创建稀疏数组 sparseArr int[sum+1][3]。

这个sum+1的意思是保存着原二维数组基本信息，既 行数，列数 ，有效值的个数。

4. 将二维数组的有效数据存入到稀疏数组中。

6.如何用java实现二维数组转成稀疏数组？

  int [][] arr= new int[11][11];
        arr[3][2]= 10;
        arr[2][3]=100;

创建了一个这样的二维数组：

public int[][] toSparseArr(int[][] arr, int i) {//形参是一个二维数组   无效的数值
        int sum = 0;
		//得到有效的数值
        for (int j = 0; j < arr.length; j++) {
            for (int k = 0; k < arr[j].length; k++) {
                if (arr[j][k] != i) {
                    sum++;
                }
            }
        }


        int count = 0;
        int[][] arr1 = new int[sum + 1][3];
        //初始化第0行
        arr1[0][0] = arr.length;
        arr1[0][1] = arr[1].length;
        arr1[0][2] = sum;
        //遍历赋值
        for (int j = 0; j < arr.length; j++) {
            for (int k = 0; k < arr[j].length; k++) {


                if (arr[j][k] != i) {
                    count++;
                    arr1[count][0] = j;
                    arr1[count][1] = k;
                    arr1[count][2] = arr[j][k];
                }
            }
        }

        return arr1;//返回一个稀疏矩阵
    }
	

运行结果：

public static void main(String[] args) {

       int[][] arr = new int[11][11];
       arr[3][2] = 10;
       arr[2][3] = 100;
       for (int i = 0; i < arr.length; i++) {
           for (int j = 0; j < arr[i].length; j++) {
               System.out.print(arr[i][j] + "\t");
           }
           System.out.println();
       }

       System.out.println("================");
       Sparsearrry sparsearrry = new Sparsearrry();
       int[][] arr1 = null;
       arr1 = sparsearrry.toSparseArr(arr, 0);

       for (int i = 0; i < arr1.length; i++) {
           for (int j = 0; j < arr1[i].length; j++) {
               System.out.print(arr1[i][j] + "\t");
           }
           System.out.println();
       }

   }

7.如何实现稀疏数组转成普通的二维数组呢。

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

8.用java代码实现稀疏数组转成普通的二维数组

 public int[][] toSimpleArr(int[][] arr) {
       int [][]arr1 = new int[arr[0][0] ] [arr[0][1]];
        for (int i = 1; i < arr.length; i++) {
                arr1[arr[i][0]][arr[i][1]]=arr[i][2];
        }

        return arr1;
    }

这个就是把原来的反过来用。
调用方法：

 arr1=sparsearrry.toSimpleArr(arr1);
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j] + "\t");
            }
            System.out.println();
        }

运行结果：