数据结构与算法分析（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;    }}