二分查找(循环+递归)

循环

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1,2,4,5,6,8,9};
        System.out.println(binarySearch(arr, 8));
    }

    /**
     * 二分查找
     * @param arr 数组
     * @param guess 要查找的元素
     * @return 元素在数组中的位置
     * 如果数组的长度为8，那么你只需要检查3个元素，如果数组中的有1024个元素，你最多需要检查10个元素
     * O(n)=O(log2n)
     */
    private static int binarySearch (int [] arr, int guess) {
        int low = 0;
        int high = arr.length-1;
        while (low <= high) {
            int mid = (low+high) / 2;
            if (guess == arr[mid]) {
                return mid;
            }
            if (guess > arr[mid]) {
                low = mid + 1;
            }
            if (guess < arr[mid]) {
                high = mid - 1;
            }
        }
        return -1;
    }
}

递归

public class BinarySearchUseRecursion {
    public static void main(String[] args) {
        int[] arr = {1,2,4,5,6,8,9};
        int index = binarySearchUseRecursion(arr,10,0, arr.length-1);
        System.out.println(index);
    }

    /**
     * 递归总有一个最简单的情况 方法的第一条总是一个包含return的条件语句。
     * 递归调用总是尝试解决一个规模更小的子问题。
     * @param arr   数组
     * @param guess 要查找的元素
     * @param low   起始索引
     * @param high  结束索引
     * @return 要查找的元素在数组中的索引
     */
    private static int binarySearchUseRecursion(int[] arr, int guess, int low, int high) {
        // 当起始索引 > 结束索引high，表明元素不存在于数组arr中
        if (low > high)
            return -1;
        int middle = (low + high) / 2;
        if (guess > arr[middle]) {
            return binarySearchUseRecursion(arr, guess, low+1, high);
        } else if (guess < arr[middle]) {
            return binarySearchUseRecursion(arr, guess, low,middle-1);
        } else {
            return middle;
        }
    }
}