数据结构 稀疏数组的压缩和稀疏数组的还原.

这是一个11*11 的原始数组 ，将其还原为稀疏数组.

目标稀疏数组

一、找出原数组的行列数和有效值的个数

代码如下

1.找出有效值总个数 summer

原始数组

        int [][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;

找出有效值总个数 summer，用于创建稀疏数组的雏形。

        //获取有效值的总个数 summer
        int summer = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length ; j++) {
                if(array[i][j] != reptition){
                    summer ++;
                }
            }

        }

2.创建一个新的数组，（压缩数组的雏形)

        //创建一个新的数组，压缩数组的雏形。
       int [][] sparseArray = new int[3][summer+1];

3.获取稀疏数组的有效值，并且对稀疏数组进进行赋值

  //获取压缩数组的有效值
  sparseArray[0][0] = array.length;
  sparseArray[0][1] = array[0].length;
  sparseArray[0][2] = summer;
  summer = 0;
  for (int i = 0; i < array.length; i++) {
      for (int j = 0; j < array[i].length ; j++) {
          if(array[i][j] != reptition){
              summer ++;
              sparseArray[summer][0] = i;
              sparseArray[summer][1] = j;
              sparseArray[summer][2] = array[i][j];
          }
      }

  }
  return sparseArray;

总代码

package xyz;

public class sparseArray {
    //数据结构 稀疏数组的压缩和稀疏数组的还原.
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println("==========================");
        int[][] sparseArray = toSparseArray(array, 0);
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                System.out.print(sparseArray[i][j] + "  ");
            }
            System.out.println();
        }
    }

    public static int[][] toSparseArray(int[][] array, int reptition) {
        //获取有效值的总个数 summer
        int summer = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != reptition) {
                    summer++;
                }
            }

        }
        //创建一个新的数组，压缩数组的雏形。
        int[][] sparseArray = new int[3][summer + 1];
        //获取压缩数组的有效值
        sparseArray[0][0] = array.length;
        sparseArray[0][1] = array[0].length;
        sparseArray[0][2] = summer;
        summer = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != reptition) {
                    summer++;
                    sparseArray[summer][0] = i;
                    sparseArray[summer][1] = j;
                    sparseArray[summer][2] = array[i][j];
                }
            }

        }
        return sparseArray;
    }

}

二、稀疏数组的还原

        int [][] sparseArray = new int [3][3];

        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = 2;
        sparseArray[1][0] = 1;
        sparseArray[1][1] = 2;
        sparseArray[1][2] = 1;
        sparseArray[2][0] = 2;
        sparseArray[2][1] = 3;
        sparseArray[2][2] = 2;

目的数组

1.通过行列数new 一个 目的数组的雏形 result

int [][] result = new int[sparseArray[0][0]][sparseArray[0][1]];

2. 将 稀疏数组sparseArray 中的有效值赋值给 目的数组result

   for (int i = 1; i < sparseArray.length; i++) {
       result[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
   }
   return result;

3.输出结果 结果数组 sparseArrayBack

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

总代码

package xyz.sparseArray;

public class sparseArrayBack {
    public static void main(String[] args) {
        int [][] sparseArray = new int [3][3];

        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = 2;
        sparseArray[1][0] = 1;
        sparseArray[1][1] = 2;
        sparseArray[1][2] = 1;
        sparseArray[2][0] = 2;
        sparseArray[2][1] = 3;
        sparseArray[2][2] = 2;
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length ; j++) {
                System.out.print(sparseArray[i][j]+"  ");
            }
            System.out.println();
        }
        System.out.println("====================");
        int [][] sparseArrayBack = sparseArrayBack(sparseArray,0);
        for (int i = 0; i < sparseArrayBack.length; i++) {
            for (int j = 0; j < sparseArrayBack[i].length; j++) {
                System.out.print(sparseArrayBack[i][j]+"  ");
            }
            System.out.println();
        }

    }
    public static int [][] sparseArrayBack(int[][] sparseArray, int reptition){
        int [][] result = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 反转
        for (int i = 1; i < sparseArray.length; i++) {
            result[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return result;
    }

}

输出结果

视频讲解点击跳转