【记】稀疏数组代码实现

1.稀疏数组代码实现

稀疏数组区别于正常数组，主要用于存储某些特殊数组数据。比如一个二维数组中有多个相同一样的值就可以使用稀疏数组去转换这个数组，然后存储这个数组，达到减少空间的算法。

• 转换的形式：

• 代码实现：

  package com.datastructure;
  
  
  /**
   * @author Hacah
   */
  public class SparseArray {
  
      public static void main(String[] args) {
          //创建一个原始的二维数组 11 * 11
          //0表示没有棋子，1表示黑子，2表示白子
          int chessArr[][] = new int[11][11];
          chessArr[1][2] = 1;
          chessArr[2][3] = 2;
          chessArr[3][6] = 1;
  
          //输出数组原始二维数组
          printArrays(chessArr);
  
          int[][] sparseArr = originToSparse(chessArr);
          sparseToOrigin(sparseArr);
  
  
      }
  
      /**
       * 稀疏数组转换为原始数组
       *
       * @param sparseArr
       * @return
       */
      public static int[][] sparseToOrigin(int[][] sparseArr) {
          //1.先读取第一行得到数组结构,创建恢复原始数组
          int[][] chessArr = new int[sparseArr[0][0]][sparseArr[0][1]];
          //2.遍历稀疏数组，从第二行开始,得到元素数据，存放到恢复原始数组
          for (int i = 1; i < sparseArr.length; i++) {
              chessArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
          }
          //3.输出恢复数组
          System.out.println("恢复后的数组：");
          printArrays(chessArr);
          return null;
      }
  
      /**
       * 原始数组转换为稀疏数组
       *
       * @param chessArr
       * @return int[][]
       */
      public static int[][] originToSparse(int[][] chessArr) {
          //原始数组的行
          int r = chessArr.length;
          //原始数组的列
          int c = chessArr[0].length;
  
          //1.将二维数组转为稀疏数组
          //2遍历二位数组得到非0元素个数
          int sum = 0;
          for (int i = 0; i < r; i++) {
              for (int j = 0; j < c; j++) {
                  if (chessArr[i][j] != 0) {
                      sum++;
                  }
              }
          }
  
          //2.2创建稀疏数组
          int sparseArr[][] = new int[sum + 1][3];
          sparseArr[0][0] = r;
          sparseArr[0][1] = c;
          sparseArr[0][2] = sum;
  
          //3遍历二位数组。得到非零数的索引
          //记录第几个非零数据
          int count = 0;
          for (int i = 0; i < r; i++) {
              for (int j = 0; j < c; j++) {
                  if (chessArr[i][j] != 0) {
                      count++;
                      sparseArr[count][0] = i;
                      sparseArr[count][1] = j;
                      sparseArr[count][2] = chessArr[i][j];
                  }
              }
          }
  
          //4输出稀疏数组
          System.out.println();
          System.out.println("得到的稀疏数组为：");
          printArrays(sparseArr);
          System.out.println();
  
          return sparseArr;
  
      }
  
      /**
       * 打印二维数组
       */
      public static void printArrays(int[][] array) {
          for (int[] row : array) {
              for (int col : row) {
                  System.out.printf("%d\t", col);
              }
              System.out.println();
          }
      }
  
  }