二分查找算法及扩展优化

有序数组中查找无重复元素的位置

二分查找就是将查找的值和子数组的中间值作比较，如果被查找的值小于中间值，就在左子数组继续查找；如果大于中间值，就在右子数组中查找，否则中间值就是要找的元素

public class BinarySearch{
    // 非递归方式
    public int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            // (left + right)/2 不用这个是因为 两个int类型值相加更容易超出Integer.MaxValue
            int mid = left + (right - left) / 2;
            if (target == arr[mid]) {
                return mid;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
    
    // 递归方式
    public static int binarySearch(int[] arr, int target, int left, int right) {
        if (left > right) {
            return -1;
        }

        int mid = left + (right - left) / 2;
        if (target < arr[mid]) {
            return binarySearch(arr, target, left, mid - 1);
        } else if (target > arr[mid]) {
            return binarySearch(arr, target, mid + 1, right);
        } else {
            return mid;
        }
    }
}

有序数组中查找有重复元素的位置

1. 寻找元素第一次出现的位置

public int binarySearch_first(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (target <= arr[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    // 如果不判断left < arr.length,如果查找一个数组中不存在且大于数组中最大元素的数会数组越界
    if (left < arr.length && arr[left] == target) {
        return left;
    }

    return -1;
}

2. 寻找元素最后一个次出现的位置

public int binarySearch_last(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (target >= arr[mid]) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    if (right >= 0 && arr[right] == target) {
        return right;
    }

    return -1;
}

3. 寻找第一个大于或等于目标值的元素位置

public static int binarySearch_first(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (target <= arr[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return left;
}

// 寻找第一个大于目标值的元素位置
public static int binarySearch_first(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (target < arr[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return left;
}

时间复杂度：O(logn)