在一个有序数组中，寻找一个target，返回其下标

  1. public int binarySearch(int[] nums, int target) {
  2.     int size = nums.length;
  3.     if (size == 0) return -1;
  4.     //全闭区间
  5.     int left = 0, right = size-1;
  6.     while (left <= right) {
  7.         int mid = left + (right - left) / 2;
  8.         if (nums[mid] == target) {
  9.             return mid;
  10.         } else if (nums[mid] < target) { //target在右侧，缩左侧边界
  11.             left = mid+1;
  12.         } else if (nums[mid] > target) {
  13.             right = mid - 1;
  14.         }
  15.     }
  16.     return -1;
  17. }

在一个有序数组中，寻找左侧边界，返回其下标

  1. public int left_bound(int[] nums, int target) {
  2.     if (nums.length == 0) return -1;
  3.     //左闭右开
  4.     int left = 0, right = nums.length;
  5.     while (left < right) {
  6.         int mid = left + (right - left) / 2;
  7.         if (nums[mid] == target) {
  8.             right = mid; //缩右边区间
  9.         } else if (nums[mid] < target) {
  10.             left = mid + 1;
  11.         } else if (nums[mid] > target) {
  12.             right = mid; //因为是开的，所以取mid
  13.         }
  14.     }
  15.     return right;
  16. }

在一个有序数组中，寻找右侧边界，返回其下标

  1. public int right_bound(int[] nums, int target) {
  2.     if (nums.length == 0) return -1;
  3.     //左闭右开
  4.     int left = 0, right = nums.length;
  5.     while (left < right) {
  6.         int mid = left + (right - left) / 2;
  7.         if (nums[mid] == target) {
  8.             left = mid + 1; ////缩左边区间
  9.         } else if (nums[mid] < target) {
  10.             left = mid + 1;
  11.         } else if (nums[mid] > target) {
  12.             right = mid; //因为是开的
  13.         }
  14.     }
  15.     return left - 1;
  16. }