第01篇 稀疏数组

一、介绍

当一个数组（通常指二维数组）的大部分数据数据内容相同，少数数据不同的时候，那么我们可以用稀疏数组对原始数组进行压缩，从而达到节省空间的目的。

二、特点

稀疏数组有以下特点：

1. 行数不固定，列数固定为3；
2. 第一行的元素分别为：第一列是原始数组的行数、第二列是原始数组的列数、第三列是原始数组中除了默认值（就是大多数值，这个不保存）之外其他值的个数
3. 其他行每行记录原始数组中某个数据的行下标、列下标、值
   如：

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

转换为稀疏数组的结果如下

4	5	5	
0	4	1	
1	3	1	
2	3	2	
3	2	2	
3	3	2	

三、实现分析

（一）原始数组转稀疏数组

1. 遍历原始数组所有元素，找出不是默认值的元素的个数sum，那么稀疏数组的行数就是sum+1（第一行保存的不是元素信息）,创建稀疏数组sparseArray[sum+1][3]
2. 按照特点的第2点对第一行进行赋值
3. 遍历原始数组，给其他行赋值，这里需要借助一个下标来记录是在记录第几个元素的信息（行、列、值）

（二）稀疏数组恢复成原始数组

1. 读取第一行，从而构建出原始数组；
2. 给数组的所有元素赋值上默认值；
3. 遍历稀疏数组，给非默认值的位置赋予正确的值。

四、代码实现

package com.firewolf.javabase.s001_sparsearray;

/**
 * 稀疏数组
 */
public class SparseArrayUtil {

  /**
   * 把二维数组转换成稀疏数组
   *
   * @param array ： 需要被转换的数组
   * @param defaultValue ：默认的值，这个值不用存储
   * @return 转换后的稀疏数组
   */
  public static Number[][] parseToSparseArray(Number[][] array, Number defaultValue) {

    //1.获取数组中不为默认值的元素个数，
    int sum = 0;
    for (Object[] row : array) {
      for (Object el : row) {
        if (!defaultValue.equals(el)) {
          sum++;
        }
      }
    }

    //构建稀疏数组
    Number[][] sparseArray = new Number[sum + 1][3]; //只有3列
    //2.稀疏数组中第一列：原始数组行、原始数组列、元素总个数
    sparseArray[0][0] = array.length;
    sparseArray[0][1] = array[0].length;
    sparseArray[0][2] = sum;

    //3.剩余的每行分别显示的是非默认值的元素信息：行下标、列下标、值
    int row = 1;
    for (int i = 0; i < array.length; i++) {
      for (int j = 0; j < array[0].length; j++) {
        if (!array[i][j].equals(defaultValue)) {
          sparseArray[row][0] = i;
          sparseArray[row][1] = j;
          sparseArray[row][2] = array[i][j];
          row += 1;
        }
      }
    }
    return sparseArray;
  }


  /**
   * 把二维数组转换成稀疏数组，默认元素为0
   *
   * @param array ： 需要被转换的数组
   * @return 转换后的稀疏数组
   */
  public static Number[][] parseToSparseArray(Number[][] array) {
    return parseToSparseArray(array, 0);
  }


  /**
   * 把稀疏数组转换成正常数组
   *
   * @param sparseArray 稀疏数组
   * @param defalutValue 默认值
   * @return 从稀疏数组恢复出来的正常数组
   */
  public static Number[][] parseFromSparseArray(Number[][] sparseArray, Number defalutValue) {

    //1.从第一行提取原数组的行数、列数，从而初始化数组
    int rows = sparseArray[0][0].intValue(); //行数
    int cols = sparseArray[0][1].intValue(); //列数
    int sum = sparseArray[0][2].intValue();//元素总个数
    Number[][] array = new Number[rows][cols];


    //2.先全部都给上默认值
    for (int i = 0; i < rows; i++) {
      for (int j = 0; j < cols; j++) {
        array[i][j] = defalutValue;
      }
    }

    //3. 恢复稀疏数据
    for (int i = 1; i <= sum; i++) {
      array[sparseArray[i][0].intValue()][sparseArray[i][1].intValue()] = sparseArray[i][2];
    }
    return array;
  }


  /**
   * 把稀疏数组转换成正常数组，默认填充元素为0
   *
   * @param sparseArray 稀疏数组
   * @return 从稀疏数组恢复出来的正常数组
   */
  public static Number[][] parseFromSparseArray(Number[][] sparseArray) {
    return parseFromSparseArray(sparseArray, 0);
  }


  /**
   * 显示二维数组
   *
   * @param array 要显示的数组
   */
  public static void showArray(Number[][] array) {
    for (Number[] row : array) {
      for (Number el : row) {
        System.out.print(el.toString() + "\t");
      }
      System.out.println();
    }
  }
}