LeetCode 刷题--二分法

69. x的平方根

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:
输入: 4
输出: 2

示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。

public class mySqrt {
    public static void main(String[] args) {
        System.out.println(mysqrt(8));
    }
    public static int mysqrt(int x){
        //对x求平方根
        //平方跟一定是在0-x/2这个范围内的
        if(x <= 1){
            return x;
        }
        int left = 1;
        int right = x/2;
        while(left <= right){
            int mid = left + (right - left)/2;
            if(mid == x/mid ){
                return mid;
            }else if(mid > x/mid){
                //说明mid的平方大于x
                //数值找大了
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        return left-1;
        //因为比如8的平方跟，取得是2而不是3
        //此时left已经大于right，越界了，说明left此时取到的数字是3.
    }

}

744. 寻找比目标字母大的最小字母

给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。

数组里字母的顺序是循环的。举个例子，如果目标字母target = ‘z’ 并且有序数组为 letters = [‘a’, ‘b’]，则答案返回 ‘a’。

示例:

输入:
letters = [“c”, “f”, “j”]
target = “a”
输出: “c”

输入:
letters = [“c”, “f”, “j”]
target = “c”
输出: “f”

输入:
letters = [“c”, “f”, “j”]
target = “d”
输出: “f”

输入:
letters = [“c”, “f”, “j”]
target = “g”
输出: “j”

输入:
letters = [“c”, “f”, “j”]
target = “j”
输出: “c”

输入:
letters = [“c”, “f”, “j”]
target = “k”
输出: “c”
//二分法的模板代码

class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
   
    //看到有序二字，我们首先就应该想到二分搜索
    //打破循环时，l最多等于r
    int n = letters.length;
    int l = 0;
    int r = n;//左闭右开
    while(l<r){
        int m = l+(r-l)/2;
        if(letters[m] <= target){
            l = m+1;
        }else{
            r = m;
        }
    }
       //如果找遍数组，都没有找到比target大的，就返回letters【0】
       return l < n ? letters[l] : letters[0];
    }
}

//关于l<h 还是l<=h,l<h可以取到l=h的情况，这道题显然不是。

540. 有序数组的单一元素

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:
输入: [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:
输入: [3,3,7,7,10,11,11]
输出: 10

class Solution {
    public int singleNonDuplicate(int[] nums) {
   
     int l = 0;
     int r = nums.length-1;  //不能使用左闭右开，会导致越界
     while(l<r){
         int m = l+(r-l)/2;
         int n = m%2== 0 ? m+1:m-1;
         if(nums[m] == nums[n]){
             //说明左面没有
             l = m + 1;
         }else{
             r = m;
         }
     }
     return nums[l];
     //l总指向不满足条件的第一个元素。
    }
}

278. 第一个错误的版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

/* The isBadVersion API is defined in the parent class VersionControl.
      boolean isBadVersion(int version); */

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        //前面版本都是好的，从第一个错误的版本之后，后面的都是坏的
        //要找出第一个错误的版本
        //用二分法
        int l = 0;
        int r = n;
        while(l<r){
            int mid = l + (r-l)/2;
            if(isBadVersion(mid)== false){
                l = mid + 1;
            }else{
                r = mid;
            }
        }
        return l;
        
    }
}

153. 寻找旋转排序数组中的最小值

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。

示例 1:
输入: [3,4,5,1,2]
输出: 1

示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0

class Solution {
    public int findMin(int[] nums) {
        //数组被分成了两个部分
        //旋转部分的第一个点就是最小的数字
     int l =0;
     int r = nums.length-1;
     while(l<r){
         int mid = l +(r-l)/2;
         //开始数组是有序的，例如0，1，2，4，5，6，7
         //然后进行了翻转  4，5，6，7，0，1，2
         //所以临界点0，在最初是数组左边的，现在变成了数组右边
         //在二分法进行缩小搜索范围时，我们想找出来左右两边的分割点，
         //也就是现在数组左边的数必须要大于数组右边的数
        //以此作为判断点
        //mid 在左半边，砍掉左半边## 标题
         if(nums[mid] > nums[r]){
              l = mid+1;
         }else{
              r = mid;
         }
     }
     return nums[l];
    }
}

34. 在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

class Solution {
    public int[] searchRange(int[] nums, int target) {
        
        //两次二分搜索去找
         int[] res = new int[2];
         res[0] = binarySearch1(nums,target);
         res[1] = binarySearch2(nums,target);
         return res;
        }
        public int binarySearch1(int[] nums, int target){
            //搜索第一个target的位置
            //找第一个等于8的值的索引
            int l = 0;
            int n = nums.length;
            int r = n -1;
            while(l <= r){
                int m = l+(r-l)/2;
                if(nums[m] < target){
                    l = m+1;
                }else{
                    r = m-1;   
                }    
            }
            return l<n && nums[l] == target? l :-1;       
        }
         public int binarySearch2(int[] nums, int target){
            //搜索最后一个target的位置
            //最后一个等于target的值的索引
              int l = 0;
              int n = nums.length;
              int r = n -1;
              while(l <= r){
                int m = l+(r-l)/2;
                if(nums[m] <= target){
                    l = m+1;
                }else{
                    r = m-1;   
                }
            }
             return r>=0 && nums[r] == target? r :-1;        
        }

    }

最后附上二分法的全部写法合集

package yu.practiceLeetCode02.shuangzhizhen;

public class BinarySort {
    public static void main(String[] args) {
        //二分法前提是一个有序的数组，这里都采用从小到的的数组
        int[] nums = {1,2,3,4,5,8};
        System.out.println(binarySort1(nums,5)); //4
        System.out.println(binarySort1(nums,1));//0
        System.out.println(binarySort1(nums,6));//-1
        System.out.println(binarySort1(nums,3));//2
        System.out.println("=================================");
        int[] arr = {1,2,3,3,4,4,5,8};
        System.out.println(binarySort2(arr,9)); //-1
        System.out.println(binarySort2(arr,8));//-1
        System.out.println(binarySort2(arr,3));//4
        System.out.println(binarySort2(arr,2));//2
        System.out.println(binarySort2(arr,0));//0

        System.out.println("=================================");
        System.out.println(binarySort3(arr,9)); //-1
        System.out.println(binarySort3(arr,8));//-1
        System.out.println(binarySort3(arr,3));//2
        System.out.println(binarySort3(arr,2));//1
        System.out.println(binarySort3(arr,4));//4
        System.out.println(binarySort3(arr,0));//0
        System.out.println("=================================");
        System.out.println(binarySort4(arr,9)); //-1
        System.out.println(binarySort4(arr,3)); //2
        System.out.println("=================================");
        System.out.println(binarySort5(arr,9)); //-1
        System.out.println(binarySort5(arr,3)); //3
        System.out.println("=================================");
        System.out.println(binarySort6(arr,9)); //7
        System.out.println(binarySort6(arr,4)); //5
        System.out.println("=================================");
        System.out.println(binarySort7(arr,9)); //7
        System.out.println(binarySort7(arr,4)); //3
        System.out.println(binarySort7(arr,5)); //5



    }

    /**
     * 功能：查找某个数字在数组中的索引，没找到返回-1
     * @param nums  被查找的数组
     * @param target  要查找的数字
     * @return m或者-1
     * 这是最原始的二分法写法，遵循左闭又闭区间，找到的值即为mid所在的值
     */
    public static int binarySort1(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n-1;
        while(l<=r){
            int m = l + (r-l)/2;
            if(nums[m]== target){
                return m;
            }else if(nums[m] < target){
                l = m+1; //向左逼近
            }else{
                r = m-1;//向右逼近
            }
        }
        //没找到
        return -1;
    }


    /**
     * 功能：找出比target大的第一个数字,，没找到返回-1
     * @param nums
     * @param target
     * @return
     */
    public static int  binarySort2(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n;   //这里是[0,n)左闭右开区间
        while(l<r) {  //所以无需考虑l=r的情况，因为 r= m，是取不到n的。
            int m = l + (r - l) / 2;
            if (nums[m] >= target) {
                //没找到，砍去一半儿
                l = m + 1;
            } else {
                r = m;
            }
        }
        return l>=n ? -1 : l;
    }
    /**
     * 功能：找出比大于等于target的第一个数字,，没找到返回-1
     * @param nums
     * @param target
     * @return
     */
    public static int  binarySort3(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n;   //这里是[0,n)左闭右开区间
        while(l<r) {  //所以无需考虑l=r的情况，因为 r= m，是取不到n的。
            int m = l + (r - l) / 2;
            if (nums[m] < target) {
                //没找到，砍去一半儿
                l = m + 1;
            } else {
                r = m;
            }
        }
        return l>=n ? -1 : l;
    }

    /**
     * 功能：查找某个数字在数组中的索引，没找到返回-1
     * @param nums  被查找的数组
     * @param target  要查找的数字
     * @return m或者-1
     * 这是最原始的二分法写法，遵循左闭又闭区间，找到的值即为mid所在的值
     */
    //找到第一个等于target的数字的索引
    public static int binarySort4(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n-1;
        while(l<=r){
            int m = l + (r-l)/2;
            if(nums[m] < target){
                //nums目标值大
                //从左往右搜索
                l= m+1;
            }else{
                r = m-1;
            }
        }
       //判断target有没有存在
        return l<n && nums[l]==target ? l : -1;
    }

    //找到最后一个等于target的数字的索引
    public static int binarySort5(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n-1;
        while(l<=r){
            int m = l + (r-l)/2;
            if(nums[m] > target){
                //从右向左搜索
                //去掉不满足条件的值
                r = m-1; //向左逼近
            }else{
                l = m + 1;//向右逼近
            }
        }
        //判断target有没有存在
        return r <= n && nums[r] == target ? r: -1;
    }
    //找到最后一个小于或等于target的数字
    public static int  binarySort6(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n-1;   //这里是[0,n)左闭右开区间
        while(l<=r) {  //所以无需考虑l=r的情况，因为 r= m，是取不到n的。
            int m = l + (r - l) / 2;
            if (nums[m]> target) {
                //从右边向左搜索
                //不满足去掉
                r= m -1;
            } else {
                l = m+1;
            }
        }
        return r>0 ? r : -1;
    }
    //找到最后一个小于target的数字
    public static int  binarySort7(int[] nums, int target){
        int n = nums.length;
        int l = 0;
        int r = n-1;   //这里是[0,n)左闭右开区间
        while(l<=r) {  //所以无需考虑l=r的情况，因为 r= m，是取不到n的。
            int m = l + (r - l) / 2;
            if (nums[m]>= target) {
                //从右边向左搜索
                //不满足去掉
                r= m -1;
            } else {
                l = m+1;
            }
        }
        return r>0 ? r : -1;
    }
}