二分

二分法：二分搜索法

不断缩小解可能存在的范围，从而求得问题最优解的方法

二分法的时间复杂度为O(logn)

二分题目主要分为二分查找、二分答案，二分类型分为整数二分、实数域上二分

整数二分

在闭区间[left,right]之间，不断二分，直到left = right时，循环结束

模板1：区间[left,right]被划分成[left, mid]和[mid + 1, right]

求等于key的位置以及大于key的第一个位置

模板2：区间[left, right]被划分成[left, mid - 1]和[mid, right]

求小于key的第一个位置

import org.junit.Test;
public class IntegerDichotomous {
    @Test
    public void test() {
        int[] arr = new int[]{2,2,4,6,8,9};
        System.out.print(template1(arr,3));
    }

    //模板1：区间[left,right]被划分成[left, mid]和[mid + 1, right]，mid归右边界
//    key大于等于时left=mid+1，key小于时right=mid;
//    mid=right，left=mid+1
    //求等于key的位置以及大于key的第一个位置
    public static int template1(int[] arr, int key) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int mid = (left + right) / 2;//向下取整
            if (arr[mid] >= key) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return right;
    }

    //模板2：区间[left, right]被划分成[left, mid - 1]和[mid, right]，mid归左边界
    //arr[mid]=key，left=mid,right=mid-1
    //求小于key的第一个位置
    public static int template2(int[] arr, int key) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int mid = (left + right + 1) / 2;//向上取整
            if (arr[mid] <= key) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        return right;
    }
}

浮点数二分

浮点数二分没有边界问题，对于两个数之间来说，一定是有值的

• 整数二分：4和5之间没有值
• 浮点数二分：4~4.5，4~4.25，4~4.125，4~4.0625，........  能够一直取数，那么我们就需要一个精度确定什么时候不再取数

确定精度eps，确定二分终止条件

tip：条件要求保留k位小数，精度eps=1e^(-k-2)，表示1*10的负(k+2)次方

        为什么是k+2不是k？

        如果是k，那么会有进位的问题。例如0.002~0.006保留两位小数，0.006进位0.01，0.002不进位，进位后二者之差0.01，但实际上二者差0.004。为了数据的准确性，eps向后加两位

例：给定一个浮点数，求这个浮点数的平方根，保留2位小数

import org.junit.Test;

public class FloatDichotomous {
    @Test
    public void test(){
        double key = 100.00;
        floatDichotomous(key);
    }

    public static void floatDichotomous(double key){
        double left= 0,right = key;//根据题目取数，如果题目有范围，根据题目范围取数
        while (right - left > 1e-4){
            double mid = (left + right) / 2;
            if(mid * mid >= key){
                right = mid;
            }else{
                left = mid;
            }
        }
        System.out.printf("%.2f\n", left);
    }
}

例：在-10000~10000的范围内给定一浮点数，求该浮点数的三次方根，left和right范围取-22~22（22*22*22=10648）

二分查找

上述示例，我们可以考虑到在结束时

条件1：arr[mid] = key，此时是寻找数组中的某个数

条件2：arr[mid] < key < arr[mid+1]，left = mid+1，right = mid

返回left为寻找数组中大于key的第一个数，返回right为寻找数组中小于key的第一个数

条件3：arr[mid-1] < key < arr[mid]，left = mid ，right = mid-1

返回left为寻找数组中大于key的第一个数，返回right为寻找数组中小于key的第一个数

因此我们可以根据题目条件调整代码

条件4：统计key在数组中出现的次数

寻找第一个大于key元素的下标upper，第一个小于key的元素的下标lower

次数num = upper - lower

import org.junit.Test;

public class GetNumByDIchotomy {
    @Test
    public void test() {
        int[] arr = new int[]{1,1,1,5,5,6,7,9,11};
        System.out.println(getUpper(arr,1)-getLower(arr,1));
    }

    //查找第一个大于key的位置
    public static int getUpper(int[] arr, int key) {
        int l = 0, r = arr.length - 1;
        int upper = 0;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (arr[mid] > key) {
                upper = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return upper;
    }

    //查找第一个大于或等于key的数的位置
    public static int getLower(int[] arr, int key) {
        int l = 0, r = arr.length - 1;
        int lower = 0;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (arr[mid] >= key) {
                lower = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return lower;
    }
}