自己写的二分查找模板(3)

二分查找真的是博大精深啊。自己又总结了一遍, 把每一类问题都归类如下:(差不多9类)

• 数组全部有序, 无重复

1. 标准二分查找
2. 大于等于目标值的数
3. 大于目标值的数
4. 小于等于目标值的数
5. 小于目标值的数

• 数组全部有序, 有重复

1. 查找目标值的左边界
2. 查找目标值的右边界

• 数组部分有序, 无重复

(例如求旋转数组的最小值, 这个时候可以把最小值看做是求右边有序序列的左边界,这就和上面那个情况一样了)

1. 查找有序段的左边界
2. 查找有序段的右边界

• 数组部分有序, 有重复

1. 目标值的左边界
2. 目标值的右边界

每一类代码如下:

    public int Search1(int[] nums, int a){//标准二分查找, 无重复, 左闭右开, 找不到返回-1
        int l = 0;
        int r = nums.length;
        while(l < r)
        {
            int m = (l+r)/2;
            if(nums[m] == a)return m;
            else if(nums[m] < a) l = m+1;
            else r = m;
        }
        return -1;
    }

    public int Search2(int[] nums, int a){//查找第一个大于等于目标值的数, 不存在则返回length,为空时返回0
        int l = 0;
        int r = nums.length;
        while(l< r)
        {
            int m =(l+r)/2;
            if(nums[m] < a) l = m+1;
            else r = m;
        }
        return l;//返回r也一样
    }

    public int Search3(int[] nums, int a){//查找第一个大于目标值的数, 不存在则返回length, 为空时返回0
        int l = 0;
        int r = nums.length;
        while(l < r)
        {
            int m = (l+r)/2;
            if(nums[m] <= a) l = m+1;
            else r = m;
        }
        return l;
    }
    public int Search4(int[] nums, int a)//查找第一个小于等于目标值的数, 不存在返回-1, 为空也返回-1
    {
        int l = -1;//左开右闭
        int r = nums.length-1;//左开右闭, 不然nums[r]会越界
        while(l < r)
        {
            int m = (l+r+1)/2;//为了砍掉右半边部分, m必须偏右
            if(nums[m]> a)r = m-1;//砍右半边
            else l = m;
        }
        return l;//返回r也一样
    }

    public int Search5(int[] nums, int a){//查找第一个小于目标值的数, 不存在返回-1, 为空也返回-1
        int l = -1;//左开右闭
        int r = nums.length-1;//左开右闭, 不然nums[r]会越界
        while(l < r)
        {
            int m = (l+r+1)/2;
            if(nums[m] >= a)r = m-1;
            else l = m;
        }
        return l;
    }

    public int Search6(int[] nums, int a){//有重复, 查找等于a的左边界, 找不到返回-1
        int l = 0;
        int r = nums.length-1; //必须nums.length-1, 不能nums.length, 返回的时候可能越界
        while(l < r)
        {
            int m = (l+r)/2;
            if(nums[m] < a) l = m+1;
            else r = m;
        }
        return nums[l] == a? l: -1;
    }

    public int Search7(int[] nums, int a){//有重复, 查找等于a的右边界, 找不到返回-1
        int l = 0;
        int r = nums.length-1;//必须nums.length-1, 不能nums.length, 返回的时候可能越界
        while(l < r)
        {
            int m = (l+r+1)/2;
            if(nums[m] > a) r = m-1;
            else r = m;
        }
        return nums[l] == a? l: -1;
    }

    public int Search8(int[] nums, int a){//部分有序, 且有重复, 找目标值的左边界
        int l = 0;
        int r = nums.length-1;
        while(l < r)
        {
            int m = (l+r)/2;
            if(nums[m]< a) 
                l = m+1;
            else if(nums[m] > a)
                r = m;
            else 
                r--;
        }
        return nums[l] == a? l: -1;
    }

    public int Search9(int[] nums, int a){//部分有序, 且有重复, 找目标值的右边界
        int l = 0;
        int r = nums.length -1;
        while(l < r)
        {
            int m = (l+r+1)/2;
            if(nums[m] > a)
                 r = m-1;
            else if(nums[m] < a)
                l = m;
            else 
                l++;
        }
        return nums[l] == a? l: -1;
    }