1 查找概论

  查找表（Search Table）是由同一类型的数据元素（或记录）构成的集合，如下所示：

  关键字（Key）是数据元素中某个数据项的值，又称为键值，用它可以标识一个数据元素，也可以标识一个记录的某个数据项（字段），我们称为关键码。
  若此关键字可以唯一地标识一个记录，则称此关键字为主关键字（Primary Key）。对于那些可以识别多个数据元素（或记录）的关键字，我们称为次关键字（Secondary Key）。
  查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。

  查找表按照操作方式来分有两大种：静态查找表和动态查找表。
  静态查找表（Static Search Table）：只作查找操作的查找表。它的主要操作有：
  (1) 查找某个特定的数据元素是否在查找表中；
  (2) 检索某个特定的数据元素和各种属性；
  动态查找表（Dynamic Search Table）：在查找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素。动态查找表的操作有两个：
  (1) 查找时插入数据元素；
  (2) 查找时删除数据元素；

  为了提高查找的效率，我们需要专门为查找操作设置数据结构，这种面向查找操作的数据结构称为查找结构。

2 顺序查找表

  顺序查找（Sequential Search）又叫线性查找，是最基本的查找技术，它的查找过程是：从表中第一个（或最后一个）记录开始，逐个进行记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录；如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功。

  代码实现较为简单：

/**
 * sequential search
 *
 * @author Korbin
 * @date 2023-04-19 11:01:06
 **/
public class SequentialSearch<T extends Comparable<T>> {

    /**
     * sequential search
     *
     * @param data search key in this array
     * @param key  to be searched key
     * @return the index of key in data
     * @author Korbin
     * @date 2023-04-19 11:23:13
     **/
    public int sequentialSearch(T[] data, T key) {
        int n = data.length;

        if (data[0].equals(key)) {
            return 0;
        }

        data[0] = key;

        int i = n - 1;
        while (!data[i].equals(key)) {
            i--;
        }
        return i;
    }

}

3 有序表查找

3.1 折半查找

  折半查找（Binary Search）技术，又称为二分查找，它的前提是线性表中的记录必须是关键码有序（通常从小到大有序），线性表必须采用顺序存储。

  折半查找的基本思想是：在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。

  代码有多种实现方式，以下是示例：

/**
 * Binary Search
 *
 * @author Korbin
 * @date 2023-04-19 17:57:03
 **/
public class BinarySearch<T extends Comparable<T>> {

    /**
     * binary search
     * <p>
     * return index in data if searched, else return -1
     *
     * @param data array to search
     * @param key  key to search
     * @return index of key in data
     * @author Korbin
     * @date 2023-04-19 18:30:33
     **/
    public int binarySearch(T[] data, T key) {
        int length = data.length;

        int from = 0;
        int to = length - 1;

        // if key little than data[0] or key greater than data[length - 1], return -1, means search failed
        if (data[from].compareTo(key) > 0 || data[to].compareTo(key) < 0) {
            return -1;
        }

        int mid = ((to - from) + 1) / 2;

        while (from < to) {

            // if data[mid] equals key, then return mid
            if (data[mid].equals(key)) {
                return mid;
            }
            if (data[mid].compareTo(key) < 0) {
                // if key greater than data[mid], then search from [mid + 1, to]
                from = Math.min(mid + 1, length - 1);
            } else if (data[mid].compareTo(key) > 0) {
                // if key little than data[mid], then search from [from, mid - 1]
                to = Math.max(mid - 1, 0);
            }

            if (from == to) {
                // if from equals to, then check if data[from] equals key
                return (data[from].equals(key)) ? from : -1;
            }
            
            mid = from + ((to - from) + 1) / 2;

        }
        return -1;
    }

}

3.2 插值查找

  插值查找（Interpolation Search）是根据要查找的关键字key与查找表中最大最小记录的关键字比较后的查找方法，其核心在于插值公式$\frac{key-a[from]}{a[to]-a[flow]}$。

  从时间复杂度来看，它也是O(logn)，但对于表长较大，而关键字又分布比较均匀的查找表来说，插值查找的平均性能要比折半查找算法的性能要好很多。反之，如果数组分布不均匀，用插值查找未必有优势。

  插值查找是在折半查找的基础上进行优化的，在折半查找中，计算mid的算法为：

  $mid=from+\frac{1}{2}((to-from)+1)$

  在插值查找算法中，则是：

  $mid=from+\frac{key-a[from]}{a[to]-a[flow]}((to-from)+1)$

  因此代码只作少量改动：

/**
 * interpolation search
 * <p>
 * return index in data if searched, else return -1
 *
 * @param data array to search
 * @param key  key to search
 * @return index of key in data
 * @author Korbin
 * @date 2023-04-19 18:30:33
 **/
public int interpolationSearch(int[] data, int key) {

    int length = data.length;

    int from = 0;
    int to = length - 1;

    // if key little than data[0] or key greater than data[length - 1], return -1, means search failed
    if (data[from] > key || data[to] < key) {
        return -1;
    }

    int mid = ((key - data[from]) / (data[to] - data[from])) / 2 * ((to - from) + 1);

    while (from < to) {

        // if data[mid] equals key, then return mid
        if (data[mid] == key) {
            return mid;
        }
        if (data[mid] < key) {
            // if key greater than data[mid], then search from [mid + 1, to]
            from = Math.min(mid + 1, length - 1);
        } else if (data[mid] > key) {
            // if key little than data[mid], then search from [from, mid - 1]
            to = Math.max(mid - 1, 0);
        }

        if (from == to) {
            // if from equals to, then check if data[from] equals key
            return (data[from] == key) ? from : -1;
        }

        mid = from + ((key - data[from]) / (data[to] - data[from])) / 2 * ((to - from) + 1);

    }
    return -1;
}

  调整一下mid的计算方式即可。