力扣二分查找热题总结（JAVA语言）

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

比最常见的二分法查找题目稍复杂了一点，数组是有序的，但目标值不唯一，需要找到目标值的下标范围。在二分查找的基础上，只需要添加一步，当找到目标值后，向左移动，找到最左的目标值，向右移动，找到最右的目标值即可。

    public int[] searchRange(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid]==target){
                int i = mid;
                while(i>=1 && nums[i-1]==target){
                    i--;
                }
                int j = mid;
                while(j<nums.length-1 && nums[j+1]==target){
                    j++;
                }
                return new int[]{i,j};
            }
            if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid +1;
            }
        }
        return new int[]{-1,-1};
    }

33. 搜索旋转排序数组

这道题一看似乎不符合二分法最基本的特性：有序数组，但这种对有序数组进行反转后的数组仍具有特殊的性质：数组的左半边和右半边总存在一边是有序的，因此可以通过mid位置和left位置元素的大小关系来判断左边是否有序，若左边有序，且target的大小在mid和left元素之间，则可将目标范围左移，否则右移。若左边无序，则右边一定有序，若target的大小在mid和right元素之间，则目标范围右移，否则左移。

    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = left + ((right-left)>>1);
            if(target==nums[mid]) return mid;
            if(nums[mid]>=nums[left]){//左有序
                if(target>=nums[left] && target<nums[mid]){
                    right = mid-1;
                }else{
                    left = mid+1;
                }
            }else{//右有序
                if(target>nums[mid] && target<=nums[right]){
                    left = mid+1;
                }else{
                    right = mid-1;
                }
            }
        }
        return -1;
    }

81. 搜索旋转排序数组 II

这道题是上一道题的衍生版，不同之处是，这道题中的数组是可以有重复元素的，如果继续用上道题的思路，判断左边有序还是右边有序时，可能会出现mid和left的元素相等的情况，如：{2,2,1,2} 以及{2,1,2,2} 导致无法判断mid的左边有序还是右边有序，那么，对于这种mid和left或right元素相等的情况，就让left++,或right–，因为如果mid元素不为target，那与之相等的left或right也不会是，将其排除在目标范围之外即可。

    public boolean search(int[] nums, int target) {
        int left = 0;
        int right =nums.length-1;
        while(left<=right){
            int mid =left + ((right-left)>>1);
            if(nums[mid]==target) return true;
            if(nums[mid]>nums[left]){//左有序
                if(target>=nums[left] && target<nums[mid]){
                    right = mid-1;
                }else{
                    left = mid+1;
                }
            }else if(nums[mid]<nums[right]){//右有序
                if(target>nums[mid] && target<=nums[right]){
                    left = mid+1;
                }else{
                    right = mid-1;       
                }
            }else if(nums[mid]==nums[left]){
                left++;
            }else{
                right--;
            }
        }
        return false;
    }

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

这道题是有序数组经过反转后找最小值，可以通过找规律发现，最小值右边的元素总是小于等于right位置的元素，最小值左边的元素总是大于right位置的元素，因此可以使用二分查找法，通过判断mid位置的元素与right位置的元素的大小关系，来判断mid是位于最小值的左边还是右边，即，目标范围应该右移还是左移。

 public int findMin(int[] nums) {
        int left = 0;
        int right = nums.length-1;
        while(left<right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid]>=nums[right]){
            //nums[mid]在最小值的左边，目标范围应右移且不包含mid位置
                left = mid + 1;
            }else{
            //nums[mid]在最小值的右边或nums[mid]就是最小值，目标范围应左移且包含mid位置
                right = mid;
            }
        }
        return nums[right];
    }

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

这道题与上道题的区别在于，数组可能存在重复元素，根据上文81题的思路，不难想到，可以在判断mid位置的元素与right位置的元素大小时，增加一个步骤：若mid位置的元素与right位置的元素大小相同，则将right左移一位，这么做是为了判断目标值在mid位置的左边还是右边从而判断目标范围应该左移还是右移，即便当right位置的元素就是最小值时，这样做也不会对结果产生影响，因为mid位置的元素跟right位置的元素相等。

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