稀疏矩阵（Java）

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

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

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

如下图：

左边是原始数组，右边是稀疏数组

 

 

应用

创建一个11*11的数组，0：没有数组，1：黑棋，2：白棋

  public class SparseArray {
      public static void main(String[] args) {
          //创建一个11*11的数组，0：没有数组，1：黑棋，2：白棋
          int[][] a = new int[11][11];
          a[1][2] = 1;
          a[2][3] = 2;
          //输出数组
          for(int i =0; i < 11; i++){
              for(int j = 0; j < 11; j++){
                  System.out.print(a[i][j]+"\t");
              }
              System.out.println();
          }
      }
  }

 

 

将数组转为稀疏数组

  
  public static void main(String[] args) {
      //创建一个11*11的数组，0：没有数组，1：黑棋，2：白棋
      int[][] a = new int[11][11];
      a[1][2] = 1;
      a[2][3] = 2;
      //输出数组
      for (int i = 0; i < 11; i++) {
          for (int j = 0; j < 11; j++) {
              System.out.print(a[i][j] + "\t");
          }
          System.out.println();
      }
      //转为稀疏数组
      System.out.println("稀疏数组：");
      //读取有效值个数
      int count = 0;
      for (int i = 0; i < 11; i++) {
          for (int j = 0; j < 11; j++) {
              if (a[i][j] != 0) {
                  count++;
              }
          }
      }
      int[][] b = new int[count + 1][3];
      //给稀疏矩阵赋值
      b[0][0] = 11;
      b[0][1] = 11;
      b[0][2] = count;
      int sum = 0;
      for (int i = 0; i < 11; i++) {
          for (int j = 0; j < 11; j++) {
              if (a[i][j] != 0) {
                  sum++;
                  b[sum][0] = i;
                  b[sum][1] = j;
                  b[sum][2] = a[i][j];
              }
          }
      }
      //输出稀疏数组
      for (int i = 0; i < count+1; i++) {
          for (int j = 0; j < 3; j++) {
              System.out.print(b[i][j] + "\t");
          }
          System.out.println();
      }
  }

 

 

还原稀疏矩阵

  
  /**
   * @author JenKinRJX
   * @create 2022-01-15-15:30
   */
  public class SparseArray {
      public static void main(String[] args) {
          //创建一个11*11的数组，0：没有数组，1：黑棋，2：白棋
          int[][] a = new int[11][11];
          a[1][2] = 1;
          a[2][3] = 2;
          //输出数组
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  System.out.print(a[i][j] + "\t");
              }
              System.out.println();
          }
          //转为稀疏数组
          System.out.println("稀疏数组：");
          //读取有效值个数
          int count = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (a[i][j] != 0) {
                      count++;
                  }
              }
          }
          int[][] b = new int[count + 1][3];
          //给稀疏矩阵赋值
          b[0][0] = 11;
          b[0][1] = 11;
          b[0][2] = count;
          int sum = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (a[i][j] != 0) {
                      sum++;
                      b[sum][0] = i;
                      b[sum][1] = j;
                      b[sum][2] = a[i][j];
                  }
              }
          }
          //输出稀疏数组
          for (int i = 0; i < count+1; i++) {
              for (int j = 0; j < 3; j++) {
                  System.out.print(b[i][j] + "\t");
              }
              System.out.println();
          }
          System.out.println("还原稀疏矩阵：");
          //还原稀疏矩阵
          int[][] c = new int[b[0][0]][b[0][1]];
          for(int i =1; i<count+1; i++){
             c[b[i][0]][b[i][1]] = b[i][2];
              }
          for(int i = 0; i<b[0][0]; i++){
              for(int j =0; j<b[0][1];j++){
                  System.out.print(c[i][j]+"\t");
              }
              System.out.println();
          }
      }
  }

  
  /**
   * @author JenKinRJX
   * @create 2022-01-15-15:30
   */
  public class SparseArray {
      public static void main(String[] args) {
          //创建一个11*11的数组，0：没有数组，1：黑棋，2：白棋
          int[][] a = new int[11][11];
          a[1][2] = 1;
          a[2][3] = 2;
          //输出数组
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  System.out.print(a[i][j] + "\t");
              }
              System.out.println();
          }
          //转为稀疏数组
          System.out.println("稀疏数组：");
          //读取有效值个数
          int count = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (a[i][j] != 0) {
                      count++;
                  }
              }
          }
          int[][] b = new int[count + 1][3];
          //给稀疏矩阵赋值
          b[0][0] = 11;
          b[0][1] = 11;
          b[0][2] = count;
          int sum = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (a[i][j] != 0) {
                      sum++;
                      b[sum][0] = i;
                      b[sum][1] = j;
                      b[sum][2] = a[i][j];
                  }
              }
          }
          //输出稀疏数组
          for (int i = 0; i < count+1; i++) {
              for (int j = 0; j < 3; j++) {
                  System.out.print(b[i][j] + "\t");
              }
              System.out.println();
          }
          System.out.println("还原稀疏矩阵：");
          //还原稀疏矩阵
          int[][] c = new int[b[0][0]][b[0][1]];
          for(int i =1; i<count+1; i++){
             c[b[i][0]][b[i][1]] = b[i][2];
              }
          for(int i = 0; i<b[0][0]; i++){
              for(int j =0; j<b[0][1];j++){
                  System.out.print(c[i][j]+"\t");
              }
              System.out.println();
          }
      }
  }