数据结构与算法分析（Java语言描述）（15）—— 二分查找（递归与非递归）

非递归

int find(int[] arr, int target){

    int l=0, r=arr.length-1;

    while(l<=r){
        int mid = (r-l)/2 + l;
        if(arr[mid] == target) return mid;
        if(arr[mid] > target) r = mid-1;
        if(arr[mid] < target) l = mid+1;
    }
    return -1;
}

package com.algorithm.search;

public class BinarySearchNotRecursive {
    private BinarySearchNotRecursive() {
    }

    // 二分查找法,在有序数组arr中,查找target
    // 如果找到target,返回相应的索引index
    // 如果没有找到target,返回-1
    public static int find(Integer[] arr, Integer target) {

        // 在arr[l...r]之中查找target
        int l = 0, r = arr.length - 1;

        while (l <= r) {

            // 防止极端情况下的整形溢出，使用下面的逻辑求出mid
            int mid = l + (r - l) / 2;

            if (arr[mid].compareTo(target) == 0) {
                return mid;
            }

            if (arr[mid].compareTo(target) > 0) {
                r = mid - 1;
            } else if (arr[mid].compareTo(target) < 0) {
                l = mid + 1;
            }
        }
        return -1;
    }

    // 测试非递归的二分查找算法
    public static void main(String[] args) {

        int N = 1000;
        Integer[] arr = new Integer[N];
        for (int i = 0; i < N; i++)
            arr[i] = new Integer(i);

        // 对于我们的待查找数组[0...N)
        // 对[0...N)区间的数值使用二分查找，最终结果应该就是数字本身
        // 对[N...2*N)区间的数值使用二分查找，因为这些数字不在arr中，结果为-1
        for (int i = 0; i < 2 * N; i++) {
            int v = BinarySearchNotRecursive.find(arr, new Integer(i));
            if (i < N) {
                System.out.print(i);
                System.out.println(v == i);
            } else {
                System.out.print(i);
                System.out.println(v == -1);
            }
        }

        return;
    }

}

---

递归

int find(int[] arr, int target){
    return find(arr, 0, arr.length-1, target);
}
int find(int[] arr, int l, int r, int target){
    if( l > r) return -1;
    int mid = (r-l)/2 + l;
    if(arr[mid] == target) return mid;
    else if(arr[mid] > target) return find(arr, l, mid—1， target);
    else returnfind(arr, mid+1, r, target);
}

package com.algorithm.search;

public class BinarySearchRecursive {
    private BinarySearchRecursive() {
    }

    public static int find(Integer[] arr, Integer target) {
        return find(arr, 0, arr.length - 1, target);
    }

    private static int find(Integer[] arr, int l, int r, Integer target) {

        if (l > r) return -1;

        // 防止极端情况下的整形溢出，使用下面的逻辑求出mid
        int mid = l + (r - l) / 2;

        if (arr[mid].compareTo(target) > 0) {
            return find(arr, l, mid - 1, target);
        } else if (arr[mid].compareTo(target) < 0) {
            return find(arr, mid + 1, r, target);
        } else { // arr[mid].compareTo(target) == 0
            return mid;
        }
    }

    // 测试递归的二分查找算法
    public static void main(String[] args) {

        int N = 1000;
        Integer[] arr = new Integer[N];
        for (int i = 0; i < N; i++)
            arr[i] = new Integer(i);

        // 对于我们的待查找数组[0...N)
        // 对[0...N)区间的数值使用二分查找，最终结果应该就是数字本身
        // 对[N...2*N)区间的数值使用二分查找，因为这些数字不在arr中，结果为-1
        for (int i = 0; i < 2 * N; i++) {
            int v = BinarySearchRecursive.find(arr, new Integer(i));
            if (i < N) {
                System.out.print(i);
                System.out.println(v == i);
            } else {
                System.out.print(i);
                System.out.println(v == -1);
            }
        }

        return;
    }


}