二分法相关

1:二分法判断一个数组中是否含有某个值

/**
 * 如何去使用二分搜索去有序数组大于等于某个数的最左侧位置
 * 二分如何考虑？
 * 用中点值和target比较
 * 如果是大于等于target{
 *     那么我们的值应该在mid的左边；设置右边界R=mid-1
 * }
 * 如果是小于target{
 *     那么我们的值应该在mid的右边；设置左边界L=mid+1
 * }
 *
 */
public class BSLeft {
    public static void main(String[] args) {
        int[] arrs={1,2,3,4,};
    }
    public static int bsLeft(int[] array,int target){
        int mid;
        int L=0;
        int R=array.length-1;
        while (L<=R){
            mid=L+((R-L)>>2);
            if (array[mid]>=target){
                //右边界不断缩进的过程
                R=mid-1;
            }else{
                L=mid+1;
            }
        }
        return L;
    }
}

2:二分法去找有序数组中大于等于某个数的最左侧值的下标

/**
 * 如何去使用二分搜索去有序数组大于等于某个数的最左侧位置
 * 二分如何考虑？
 * 用中点值和target比较
 * 如果是大于等于target{
 *     那么我们的值应该在mid的左边；设置右边界R=mid-1
 * }
 * 如果是小于target{
 *     那么我们的值应该在mid的右边；设置左边界L=mid+1
 * }
 *
 */
public class BSLeft {
    public static void main(String[] args) {
        int[] arrs={2,3,5,7};
        int i = bsLeft(arrs, 2);
        System.out.println(i);

    }
    public static int bsLeft(int[] array,int target){
        int L = 0;
        int R = array.length - 1;
        while (L <= R) {
            int mid = L + ((R - L) >> 1);
            if (array[mid] >= target) {
                R = mid - 1;
            } else {
                L = mid + 1;
            }
        }
        /**
         * [2,3,4,5] 如果目标是小于数组中的最小值或者目标大于数组中的最大值，则返回 -1
         * 其余情况 返回确定下标值
         */
        if (L==array.length){
            return -1;
        }else if (L==0){
            if (array[L]==target){
                return L;
            }else{
                return -1;
            }
        }else{
            return L;
        }
    }
}

3:二分法去找有序数组中小于等于某个数的最右侧值的下标

/**
 * 需求去找一个有序数组中大于等于某个数的最右侧位置
 * 不断向调整左侧的下标向右侧进行逼近
 */
public class BSright {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(bsRight(arr, -4));
    }

    public static int bsRight(int[] arrs, int target) {
        int L = 0;
        int R = arrs.length - 1;
        int mid;
        while (L <= R) {
            mid = L + ((R - L) >> 1);
            if (arrs[mid] <= target) {
                L = mid + 1;
            } else {
                R = mid - 1; //最后执行
            }
        }
       if (R==arrs.length){
           return -1;
       }else if (R==-1){
           return -1;
       }else {
           return R;
       }

    }
}

4:二分法找局部最小值