稀疏数组

什么是稀疏数组？

　　稀疏数组可以看作是普通数组的压缩，当普通数组只有少量有效数据时，可以使用稀疏数组的方式存储，从而达到节省空间的目的。

为什么要用稀疏数组？

　　当普通数组中只有少量有效数据时，会有大量无用数据占用空间，故可以使用稀疏数组以达到节省空间目的。

例如：int array[][] = new int[5][5];

　　　array[1][1] = 1;

         array[1][2] = 2;　　　　

        0    0    0    0    0    0
        0    1    2    0    0    0
        0    0    0    0    0    0
        0    0    0    0    0    0
        0    0    0    0    0    0

　　如上定义5*5的二维数组array，只有两个有效数据1，2。其他均为默认值0，如果直接存储array，则会浪费5*5-2个空间。

这时候就可以使用稀疏数组的方式存储，先展示使用稀疏数组存储的数据结构

        行  列  值
        5   5   2
        1   1   1
        1   2   2    

　　稀疏数组有（n+1）行3列，n=有效数据个数，其中第一行固定表示原二维数组有5行5列有效值有2个。后面n行依次表示原二维数组中的有效数据分别在第几行第几列及对应值

使用稀疏数组只保存有效数据，因此适用于原二维数组只有少量有效数据的情况，而如果原数组大部分数据为有效数据，再转为稀疏数组反而占用更多的空间(m行*n列*3)

如何实现稀疏数组？

　　1.将二维数组转为稀疏数组方法

1. public static int[][] arrayToSparseArray(int[][] array) {
           //统计有多少个非0数据
           int sum = 0;
           for(int i=0;i<array.length;i++){
               for(int j=0;j<array[i].length;j++){
                   if(array[i][j] != 0){
                       sum ++;
                   }
                   System.out.printf("%d\t",array[i][j]);
               }
               System.out.println();
           }
   
           System.out.println("有效数据个数="+sum);
   
           //二维数组转稀疏数组
           /**
            * 思路：1.得到二维数组的有效数据个数sum
            *      2.根据sum创建稀疏数组
            *      3.将二维数组的有效数据存入稀疏数组中
            */
           int sparseArray[][] = new int [sum+1][3];
           sparseArray[0][0] = array.length;
           sparseArray[0][1] = array[0].length;
           sparseArray[0][2] = sum;
           //遍历二维数组，并将有效数据存入稀疏数组中
           int count = 0;
           for(int i=0;i<array.length;i++){
               for(int j=0;j<array[i].length;j++){
                   if(array[i][j] != 0){
                       count ++;
                       sparseArray[count][0] = i;
                       sparseArray[count][1] = j;
                       sparseArray[count][2] = array[i][j];
                   }
               }
           }
   
           //打印稀疏数组
           for(int []row :sparseArray){
               for(int data: row){
                   System.out.printf("%d\t",data);
               }
               System.out.println();
           }
           return sparseArray;
       }

   调用方法

   public static void main(String []args){
           /**
            * 先初始化一个5*5的二维数组，包含两个值
            */
           int array[][] = new int [5][5];
           array[1][2] = 1;
           array[2][3] = 2;
           int[][] sparseArray = arrayToSparseArray(array);
   
       }

   调用结果：

   打印原数组
   0    0    0    0    0    
   0    1    2    0    0    
   0    0    0    0    0    
   0    0    0    0    0    
   0    0    0    0    0    
   有效数据个数=2
   打印稀疏数组
   5    5    2    
   1    1    1    
   1    2    2    

   2.将稀疏数组转为数组

   public static void sparseArrayToArray(int[][] sparseArray) {
           /**
            * 将稀疏数组转为二维数组
            * 思路：1.先取出稀疏数组的第一行，根据第一行数据，创建原始的二维数组
            *      2.再读取稀疏数组后几行，并赋值给原始的二维数组
            */
           int backArray[][] = new int [sparseArray[0][0]][sparseArray[0][1]];
   
           for(int i=1;i<sparseArray.length;i++){
               backArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
           }
   
           //打印原始二维数据
           System.out.println("稀疏数组转为二维数组后的数据：");
           for(int rows[] : backArray){
               for(int data: rows){
                   System.out.printf("%d\t",data);
               }
               System.out.println();
           }
       }

   调用方法

   public static void main(String []args){
           /**
            * 先初始化一个5*5的二维数组，包含两个值
            */
           int array[][] = new int [5][5];
           array[1][1] = 1;
           array[1][2] = 2;
           int[][] sparseArray = arrayToSparseArray(array);
   
           sparseArrayToArray(sparseArray);
       }

   调用结果

   稀疏数组转为二维数组后的数据：
   0    0    0    0    0    
   0    1    2    0    0    
   0    0    0    0    0    
   0    0    0    0    0    
   0    0    0    0    0    

总结

　　当使用普通数组，且只有少量有效数据存储在数组中时，可以将其转换为稀疏数组的方式进行存储（上述代码没有保存到文件中，后续更新)，从而达到节省空间的目的。