定义

在不改变数值相对大小的情况下，即大小顺序不变，修改数值以缩小数据范围。
参见百度百科：离散化

实现

允许有相同的数，相同的数离散化后任仍然一样。

  1. import java.util.Iterator;
  2. import java.util.SortedSet;
  3. import java.util.TreeSet;
  5. public class Discretization {
  6.     // 原始数组
  7.     private int[] raw;
  8.     // 离散化后的数组
  9.     private int[] value;
  11.     /**
  12.      * 构造函数
  13.      *
  14.      * @param a 原始数组
  15.      */
  16.     public Discretization(int[] a) {
  17.         raw = a.clone();
  18.         // TreeSet可以同时实现排序和去重
  19.         SortedSet<Integer> tmpSet = new TreeSet<Integer>();
  20.         for (int i : a) {
  21.             tmpSet.add(i);
  22.         }
  24.         int[] tmpArray = new int[tmpSet.size()];
  25.         int index = 0;
  26.         for (Iterator<Integer> i = tmpSet.iterator(); i.hasNext(); ) {
  27.             tmpArray[index++] = i.next();
  28.         }
  30.         value = raw.clone();
  31.         for (int i = 0; i < value.length; ++i) {
  32.             value[i] = lowerBound(tmpArray, value[i]);
  33.         }
  34.     }
  36.     /**
  37.      * 大于等于target的最小数的下标
  38.      *
  39.      * @param a      已升序排列的数组
  40.      * @param target 下限值
  41.      * @return 大于等于target的最小数的下标
  42.      */
  43.     private int lowerBound(int[] a, int target) {
  44.         int l = 0;
  45.         int r = a.length - 1;
  46.         int mid;
  47.         while (l < r) {
  48.             mid = (l + r) / 2;
  49.             if (a[mid] >= target) {
  50.                 r = mid;
  51.             } else {
  52.                 l = mid + 1;
  53.             }
  54.         }
  55.         return l;
  56.     }
  58.     public int[] getRaw() {
  59.         return raw;
  60.     }
  62.     public int[] getValue() {
  63.         return value;
  64.     }
  65. }

参考链接

https://blog.csdn.net/Viscu/article/details/82631062