Java修炼之凡界篇 筑基期 第05卷 数组 番外1 稀疏数组

稀疏数组

• 稀疏数组是一种数据结构

• 当一个数组中大部分元素为0，或者为同一数值时，可以使用稀疏数组来保存该数组（压缩数据）

• 稀疏数组的处理方式：

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

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

• 程序案例：

  public class SparseArray {
  
      public static void main(String[] args) {
          /**
           * 原始数组[6][7]
           * 0   0   0   22   0   0   15
           * 0   11  0   0    0   17  0
           * 0   0   0   -6   0   0   0
           * 0   0   0   0    0   39  0
           * 91  0   0   0    0   0   0
           * 0   0   28  0    0   0   0
           *
           * 稀疏数组（二维数组）
           *      行（row）      列（col）      值（value）
           * [0]      6           7               8
           * [1]      0           3               22
           * [2]      0           6               15
           * [3]      1           1               11
           * [4]      1           5               17
           * [5]      2           3               -6
           * [6]      3           5               39
           * [7]      4           0               91
           * [8]      5           2               28
          */
  
          System.out.println("===========1、原始数组===========");
          // 原始数组
          int[][] ints = new int[6][7];
          ints[0][3] = 22;
          ints[0][6] = 15;
          ints[1][1] = 11;
          ints[1][5] = 17;
          ints[2][3] = -6;
          ints[3][5] = 39;
          ints[4][0] = 91;
          ints[5][2] = 28;
  
          pringtArrays(ints);
  
          System.out.println("===========2、稀疏数组===========");
          // 原始数组进行压缩转换为稀疏数组
          // 稀疏数组只有三列，行列和值
          // 行数为有效数值的个数，稀疏数组需要剔除表头部分，下标1开始才是数值的存储
          int sumNum = sumArrays(ints);
          int[][] sparseArray  = new int[sumNum + 1][3];
  
          // 存储稀疏数组的表头，行列数值
          sparseArray[0][0] = 6;
          sparseArray[0][1] = 7;
          sparseArray[0][2] = sumNum;
  
          int count = 0;
          for (int i = 0; i < ints.length; i++) {
              for (int j = 0; j < ints[i].length; j++) {
                  if(ints[i][j] != 0){
                      count++;
                      // 行
                      sparseArray[count][0] = i;
                      // 列
                      sparseArray[count][1] = j;
                      // 值
                      sparseArray[count][2] = ints[i][j];
                  }
              }
          }
          pringtArrays(sparseArray);
  
          System.out.println("===========3、数组还原===========");
          // 确定还原数组的行列
          int[][] restoreArray  = new int[sparseArray[0][0]][sparseArray[0][1]];
          // 不含表头，下标从1开始
          for (int i = 1; i < sparseArray.length; i++) {
              int row = sparseArray[i][0];
              int col = sparseArray[i][1];
              int value = sparseArray[i][2];
              restoreArray[row][col] = value;
          }
          pringtArrays(restoreArray);
      }
  
      public static int sumArrays(int[][] ints){
          int sumNum = 0;
          for (int i = 0; i < ints.length; i++) {
              for (int j = 0; j < ints[i].length; j++) {
                  if(ints[i][j] != 0){
                      sumNum++;
                  }
              }
          }
          return sumNum;
      }
  
      public static void pringtArrays(int[][] ints){
          for (int i = 0; i < ints.length; i++) {
              for (int j = 0; j < ints[i].length; j++) {
                  System.out.print(ints[i][j] + "\t");
              }
              System.out.println();
          }
      }
  }
  // --------------------------------------
  // 控制栏输出打印：
  /**
   ===========1、原始数组===========
   0 0  0  22 0  0  15
   0 11 0  0  0  17 0
   0 0  0  -6 0  0  0
   0 0  0  0  0  39 0
   91 0  0  0  0  0  0
   0 0  28 0  0  0  0
   ===========2、稀疏数组===========
   6 7  8
   0 3  22
   0 6  15
   1 1  11
   1 5  17
   2 3  -6
   3 5  39
   4 0  91
   5 2  28
   ===========3、数组还原===========
   0 0  0  22 0  0  15
   0 11 0  0  0  17 0
   0 0  0  -6 0  0  0
   0 0  0  0  0  39 0
   91 0  0  0  0  0  0
   0 0  28 0  0  0  0
   */