认识二分法

经常见到的类型是在一个有序数组上，开展二分搜索，但有序真的是所有问题求解时使用二分的必要条件吗？
不
只要能正确构建左右两侧的淘汰逻辑（排它性），你就可以二分。

问题一

在一个有序数组中，找到某个数是否存在

/**
 * 有序数组中，找某个数是否存在
 */
public class BSExit {
    public static boolean isExit(int[] arr,int value){
        if(arr == null || arr.length == 0){
            return false;
        }
        int L = 0;
        int R = arr.length - 1;
        int mid;
        while (L < R){
            mid = (L + R) / 2;
            if(arr[mid] == value){
                return true;
            }else if(arr[mid] > value){
                R = mid - 1;
            }else {
                L = mid + 1;
            }
        }
        return arr[L] == value;
    }


    //for test
    private static boolean isExitForTest(int[] arr,int value){
        if(arr == null || arr.length < 2){
            return false;
        }
        for (int v : arr) {
            if(v == value){
                return true;
            }
        }
        return false;
    }

    //生成一个随机数组 for test
    private static int[] generateRandomArray(int maxLength,int maxValue){
        int[] arr = new int[(int) ((maxLength + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }


    public static void main(String[] args) {
        int maxLength = 10;
        int maxValue = 10;
        int testTime = 1000;
        System.out.println("测试开始");
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxLength, maxValue);
            Arrays.sort(arr);
            boolean b1 = isExit(arr, 3);
            boolean b2 = BSExist.exist( arr, 3);
            if(b1 != b2){
                System.out.println("出错啦");
            }
        }
        System.out.println("测试结束");
    }
}

问题二

在一个有序数组中，找>=某个数最左侧的位置

/**
 * 有序数组 >某个数最左侧位置
 */
public class BSNearLeft {

    public static int nearestIndex(int[] arr,int value){
        if(arr == null || arr.length == 0){
            return -1;
        }
        int L = 0;
        int R = arr.length - 1;
        int mid;
        int index = -1;
        while (L <= R){
            mid = (L + R) / 2;
            if(arr[mid] >= value){
                index = mid;
                R = mid - 1;
            }else {
                L = mid + 1;
            }
        }
        return index;
    }


    // for test
    public static int test(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= value) {
                return i;
            }
        }
        return -1;
    }

    // for test
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    // for test
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            Arrays.sort(arr);
            int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, value) != nearestIndex(arr, value)) {
                printArray(arr);
                System.out.println(value);
                System.out.println(test(arr, value));
                System.out.println(nearestIndex(arr, value));
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }
}

问题三

在一个有序数组中，找<=某个数最右侧的位置

/**
 * .在一个有序数组中，找<=某个数最右侧的位置
 */
public class BSNearRight {

    public static int nearestIndex(int[] arr,int value){
        if(arr == null || arr.length ==0){
            return -1;
        }
        int L = 0;
        int R = arr.length - 1;
        int mid;
        int index = -1;

        while (L <= R){
            mid = (L + R) / 2;
            if(arr[mid] <= value){
                index = mid;
                L = mid + 1;
            }else {
                R = mid - 1;
            }
        }
        return index;
    }


    // for test
    public static int test(int[] arr, int value) {
        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] <= value) {
                return i;
            }
        }
        return -1;
    }

    // for test
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    // for test
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            Arrays.sort(arr);
            int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, value) != nearestIndex(arr, value)) {
                printArray(arr);
                System.out.println(value);
                System.out.println(test(arr, value));
                System.out.println(nearestIndex(arr, value));
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }

}

问题四

局部最小值问题。在一个无序数组中找到一个局部最小值。比两边都小就是局部最小。

/**
 * 局部最小值
 */
public class BSAwesome {

    public int getLessIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return -1; //no exit
        }
        if (arr.length == 1 || arr[0] < arr[1]) {
            return 0;
        }
        if (arr[arr.length - 1] < arr[arr.length - 2]) {
            return arr.length - 1;
        }
        int L = 1;
        int R = arr.length - 2;
        int mid;
        while (L < R) {
            mid = (L + R) / 2;
            if(arr[mid] > arr[mid - 1]){
                R = mid - 1;
            }else if(arr[mid] > arr[mid + 1]){
                L = mid + 1;
            }else {
                return mid;
            }
        }
        return L;
    }

}