老實說，差值查詢與二分查詢在實現上基本沒什麼區別。

相對於二分查詢來說，查值查詢更在乎資料的分佈規律，換句話說，查值查詢會根據資料的分佈情況，來決定要選擇的拆分點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為要查詢的陣列。