算法--查找--差值查找

老实说，差值查找与二分查找在实现上基本没什么区别。

相对于二分查找来说，查值查找更在乎数据的分布规律，换句话说，查值查找会根据数据的分布情况，来决定要选择的拆分点middle，从而实现优化。比如现在一个长度为100，分别存放着1到100的整数，我们要查找2，就不会从50这个点来拆分，而是会选择较小的数值。

条件：

(1)数据必须采用顺序存储结构；(2)数据必须有序。

原理：

与二分查找类似，区别在于拆分点的选取。

时间复杂度：

最好的情况下，即数据在某个范围内均匀分布时，时间复杂度为O（loglogn），可见优化不少。

实现：

还是比较简单的。
能上代码，就不多说话。

public class Dsearch {
    /**
     * <p>name: main</p>
     * <p>description: </p>
     * <p>return: void</p>
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        System.out.println(dsearch(array, 10, 0, 8));
        System.out.println(dsearch(array, 1, 0, 8));       
    }

    /**
     * <p>
     * name: dsearch
     * </p>
     * <p>
     * description:与二分查找相比，区别只在于 middle = low + (hight - low) / (array[hight] -
     * array[low]) * (a - array[low]);
     * </p>
     * <p>
     * return: int 数组下标
     * </p>
     */
    public static int dsearch(int[] array, int a) {
        if (array == null || array.length == 0) {
            return -1;
        }
        if (array[array.length - 1] == a) {
            return array.length - 1;
        } else if (array[0] == a) {
            return 0;
        }
        int low = 0;
        int hight = array.length - 1;
        while (low <= hight) {
            int middle = low + (hight - low)
                    / (array[hight] - array[low]) * (a - array[low]);
            if (array[middle] < a) {
                low = middle + 1;
            } else if (array[middle] > a) {
                hight = middle - 1;
            } else {
                return middle;
            }
        }
        return -1;
    }

    /**
     * <p>
     * name: dsearch
     * </p>
     * <p>
     * description:与二分查找相比，区别只在于 middle = low + (hight - low) / (array[hight] -
     * array[low]) * (a - array[low]);
     * </p>
     * <p>
     * return: int 数组下标
     * </p>
     */
    public static int dsearch(int[] array, int a, int low, int hight) {
        if (array == null || array.length == 0 || low > hight || a < array[low]
                || a > array[hight]) {
            return -1;
        }
        int middle = low + (hight - low) / (array[hight] - array[low])
                * (a - array[low]);
        if (a < array[middle]) {
            return dsearch(array, a, low, hight - 1);
        } else if (a > array[middle]) {
            return dsearch(array, a, low + 1, hight);
        } else {
            return middle;
        }
    }
}

不难发现，只需要将二分查找的
middle = （low + hight）/2 = low + 1/2(hight - low)修正一下即可：
middle = low + (hight - low)/(array[hight] - array[low]) x (a - array[low])
a 为目标数据，array为要查找的数组。