二分（相关部分）

/**
 * 1.普通二分（递归 && 非递归）
 * 2.包含重复元素的二分（第一个 && 最后一个）
 * 
 * @author wzl
 * @since 2020-10-07
 */
public class 二分相关 {
    /**
     * 普通二分非递归
     */
    public static int binarySearch_unRecursion(int[] array, int target) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int left = 0;
        int right = array.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (target == array[mid]) {
                return target;
            } else if (target > array[mid]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        System.out.println(left + " " + right);
        return -1;
    }
    
    /**
     * 普通二分递归
     */
    public static int binarySearch_recursion(int[] array, int target, int left, int right) {
        if (array == null || array.length == 0) {
            return -1;
        }
        if (left <= right) {
            int mid = (left + right) / 2;
            if (target == array[mid]) {
                return target;
            } else if (target > array[mid]) {
                return binarySearch_recursion(array, target, mid + 1, right);
            } else {
                return binarySearch_recursion(array, target, left, mid - 1);
            }
        }
        return -1;
    }
    
    /**
     * 重复元素二分，第一个重复元素
     * 找target - 0.5，最后判断left标志位
     */
    public static int binarySearch_repeatFirst(int[] arr, int target) {
        if (arr == null || arr.length < 0) {
            return -1;
        }
        double t = target - 0.5;
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (t > arr[mid]) {
                left = mid + 1;
            } 
            if (t < arr[mid]) {
                right = mid - 1;
            }
        }
        if (left >= 0 && left <= arr.length - 1 && arr[left] == target) {
            return left;
        }
        return -1;
    }
    
    /**
     * 重复元素二分，最后一个重复元素
     * 找target + 0.5, 最后判断 right标志位
     */
    public static int binarySearch_repeatLast(int[] arr, int target) {
        if (arr == null || arr.length < 0) {
            return -1;
        }
        double t = target + 0.5;
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (t > arr[mid]) {
                left = mid + 1;
            } 
            if (t < arr[mid]) {
                right = mid - 1;
            }
        }
        if (right >= 0 && right <= arr.length - 1 && arr[right] == target) {
            return right;
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 1};
        System.out.println();
    }
}