二分法总结

两种区间的定义，我喜欢用第一种：左闭右开

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

• 寻找第一个满足XXX的位置：左闭右开

• int left = 0, right = nums.length - 1;
  while (left < right) {
    int middle = left + (right - left) / 2;
    if (满足XXX) {
      right = middle;
    } else {
      left = middle + 1;
    }
  }

• 寻找最后一个满足XXX的位置：（在上升数组中存在重复elem的时候）右闭左开

int left = 0, right = nums.length - 1;
while (left < right) {
  // +1是为了让相除结果向上取整，这个地方就是两套模板的区别之一
  int middle = left + (right - left + 1) / 2;
  if (满足XXX) {
    left = middle;
  } else {
    right = middle - 1;
  }
}

假设你只会用 寻找第一个满足XXX 这个模板，但是遇到的实际需求是 寻找最后一个满足XXX ，你完全可以将二分目标修改为： 寻找第一个不满足XXX 的位置（也就是把 if条件 改成对应相反的，其余都不用动）。可知它的上一个位置就是 最后一个满足XXX 的。你把算出来的二分结果减去1，就是答案了。（反之同理，由 最后一个 -> 第一个 是 +1 操作）

int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }

 

用左闭右开区间解决，下面解析非常好 

疑问：为什么while的条件是low<high,而不是low<=high呢
解答：low<high，假如最后循环到{*,10,1,*}的这种情况时，nums[low]=10,nums[high]=1,nums[mid]=10,low=mid+1。
直接可以跳出循环了,所以low<high,此时low指向的就是最小值的下标;

如果low<=high的话，low=high，还会再不必要的循环一次，此时最后一次循环的时候会发生low==high==mid，则nums[mid]==nums[high]，则会走一次else语句，则low=mid+1,此时low指向的是最小值的下一个下标，则需要return[low-1]

public static int findMin(int[] nums) {
        int len = nums.length;
        int low = 0;
        int high = len-1;

//        二分查找
        while(low < high){
//            取中间值
            int mid = (high+low)/2;
//            如果中间值小于最大值，则最大值减小
//            疑问：为什么 high = mid;而不是 high = mid-1;
//            解答：{4,5,1,2,3}，如果high=mid-1，则丢失了最小值1
            if (nums[mid] < nums[high]) {
                high = mid;
            } else {
//                如果中间值大于最大值，则最小值变大
//                疑问：为什么 low = mid+1;而不是 low = mid;
//                解答：{4,5,6,1,2,3}，nums[mid]=6，low=mid+1,刚好nums[low]=1
//                继续疑问：上边的解释太牵强了，难道没有可能low=mid+1,正好错过了最小值
//                继续解答：不会错过!!! 如果nums[mid]是最小值的话，则其一定小于nums[high],走if，就不会走else了
                low = mid+1;
            }
        }
//        疑问：为什么while的条件是low<high,而不是low<=high呢
//        解答：low<high，假如最后循环到{*,10,1,*}的这种情况时，nums[low]=10,nums[high]=1,nums[mid]=10,low=mid+1,
//             直接可以跳出循环了,所以low<high,此时low指向的就是最小值的下标;
//             如果low<=high的话，low=high，还会再不必要的循环一次，此时最后一次循环的时候会发生low==high==mid，
//             则nums[mid]==nums[high]，则会走一次else语句，则low=mid+1,此时low指向的是最小值的下一个下标，
//             则需要return[low-1]
        return nums[low];
    }

 

def search(self, nums: List[int], target: int) -> int:
        #use binary search: the solution may not exist
        n = len(nums)
        left,right = 0, n-1
        while left<=right:
            mid = (left+right)//2
            if nums[mid] == target:
                return mid
            #check whether mid is in the left sorted portion or right sorted portion
            if nums[mid]>=nums[0]:
                #in left sorted portion
                if target < nums[mid] and target>=nums[0]:
                    right = mid-1
                else:
                    left = mid+1
            else:
                #in right sorted portion
                if target>nums[mid] and target<=nums[n-1]:
                    left = mid+1
                else:
                    right = mid-1
        return -1