数据结构与算法：二分法

1. 在有序数组中，查找某个数是否在数组中存在？ 使用二分法最经典。算法复杂度为(logN).

public static boolean exist(int[] sortedArr, int num){
        if(sortedArr == null || sortedArr.length == 0){
            return false;
        }

        int L = 0;
        int R = sortedArr.length - 1;
        int mid = 0; // 中间位置
        while(L<R){
            mid = L + ((R-L) >> 1);      //mid = (L + R)/2;  L+R可能会造成数据溢出
            if(sortedArr[mid] == num){
                return true;
            }else if(num < sortedArr[mid] ){
                R = mid -1;
            }else{
                L = mid + 1;
            }
        }

        return sortedArr[L] == num;
    }

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

// 找到 >= value最左边的位置
    public static int nearLeft(int[] arr, int value){
        int L= 0;
        int R = arr.length - 1;
        int index = -1;
        while(L<=R){
            int mid = L + ((R-L) >> 1);
            if(arr[mid] >= value){
                index = mid;
                R = mid -1;
            }else{
                L = mid + 1;
            }
        }
        return index;
    }

3. 找到 <= value最右侧的位置

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

4. 找到局部最小值

public static int getLessIndex(int[] arr){
        if(arr == null || arr.length == 0){
            return -1;
        }

        // 考虑最最左边是否局部最小
        if(arr.length == 1 ||  arr[0]<arr[1]){
            return 0;
        }

        // 考虑最最右边是否局部最小
        if(arr[arr.length-1] < arr[arr.length-2]){
            return arr.length - 1;
        }

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

        return left;
    }