把「二分查找」的代码做了重新编排。

Author: suanfa8

02-Binary-Search/Type-1/0004-median-of-two-sorted-arrays/src/Solution.java

@@ -11,24 +11,37 @@ public int search(int[] nums, int target) {
  int left = 0;
  int right = len - 1;
  while (left < right) {
- // 根据分支的逻辑将中位数改成右中位数
+ // 根据分支的逻辑将中间数改成上取整
  int mid = left + (right - left + 1) / 2;
  if (nums[mid] < nums[right]) {
- // 先写落在有序数组区间里的情况
+ // 此时 [mid..right] 有序
  if (nums[mid] <= target && target <= nums[right]) {
+ // 如果 target 的值落在这个区间里，下一轮搜索区间是 [mid..right]，此时设置 left = mid;
  left = mid;
  } else {
+ // 否则，下一轮搜索区间是 [left..mid - 1]，此时设置 right = mid - 1;
  right = mid - 1;
  }
  } else {
- // 先写落在有序数组区间里的情况
+ // 此时 nums[mid] >= nums[right]，注意此时 mid 可能与 right 重合
+ // 数组前半部分有序，即 [left..mid] 有序，为了与上一个分支的逻辑一致，认为 [left..mid - 1] 有序
  if (nums[left] <= target && target <= nums[mid - 1]) {
+ // 如果 target 的值落在区间 [left..mid - 1] 里，设置 right = mid - 1;
  right = mid - 1;
  } else {
+ // 否则，下一轮搜索区间是 [mid..right]，此时设置 left = mid;
  left = mid;
  }
+
+ // 补充说明：由于中间数上取整，在区间只剩下两个元素的时候，mid 与 right 重合，逻辑走到 else 分支里
+ // 此时恰好 if 这个分支看到的是 left 和 mid - 1 ，用到的都是 == 号，等价于判断 nums[left] == target
+ // 因此依然可以缩减区间，注意这里 if 里面的 nums[left] <= target && target <= nums[mid - 1] ，
+ // 不可以写成 nums[left] <= target && target < nums[mid]
  }
  }
- return nums[left] == target ? left : -1;
+ if (nums[left] == target) {
+ return left;
+ }
+ return -1;
  }
 }

02-Binary-Search/Type-1/0004-median-of-two-sorted-arrays/src/Solution2.java

@@ -0,0 +1,52 @@
+public class Solution6 {
+
+ public int search(int[] nums, int target) {
+ int n = nums.length;
+ if (n == 0) {
+ return -1;
+ }
+ if (n == 1) {
+ return nums[0] == target ? 0 : -1;
+ }
+
+ // 第一次「二分」：从中间开始找，找到满足 >=nums[0] 的分割点（旋转点）
+ int l = 0, r = n - 1;
+ while (l < r) {
+ int mid = l + r + 1 >> 1;
+ if (nums[mid] >= nums[0]) {
+ l = mid;
+ } else {
+ r = mid - 1;
+ }
+ }
+
+ // 第二次「二分」：通过和 nums[0] 进行比较，得知 target 是在旋转点的左边还是右边
+ if (target >= nums[0]) {
+ l = 0;
+ } else {
+ l = l + 1;
+ r = n - 1;
+ }
+
+ System.out.println(l);
+ System.out.println(r);
+
+ while (l < r) {
+ int mid = l + r >> 1;
+ if (nums[mid] >= target) {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return nums[l] == target ? l : -1;
+ }
+
+ public static void main(String[] args) {
+ Solution6 solution6 = new Solution6();
+ int[] nums = new int[]{1, 3};
+ int target = 0;
+ int res = solution6.search(nums, target);
+ System.out.println(res);
+ }
+}

02-Binary-Search/Type-1/0033-search-in-rotated-sorted-array/src/Solution.java

@@ -5,52 +5,58 @@ public int[] searchRange(int[] nums, int target) {
  if (len == 0) {
  return new int[]{-1, -1};
  }
-
  int firstPosition = searchFirstPosition(nums, target);
  if (firstPosition == -1) {
  return new int[]{-1, -1};
  }
-
- // 能走到这里，一定是数组中存在目标元素
+ // 能走到这里，数组中一定存在目标元素
  int lastPosition = searchLastPosition(nums, target);
  return new int[]{firstPosition, lastPosition};
  }
 
- private int searchLastPosition(int[] nums, int target) {
- int left = 0;
- int right = nums.length - 1;
- while (left < right) {
- int mid = (left + right + 1) / 2;
- if (nums[mid] > target) {
- // mid 以及 mid 的右边一定不是目标元素最后一次出现的位置
- // 下一轮搜索的区间是 [left, mid - 1]
- right = mid - 1;
- } else {
- // 下一轮搜索的区间是 [mid, right]
- left = mid;
- }
- }
- return left;
- }
-
  private int searchFirstPosition(int[] nums, int target) {
  int left = 0;
  int right = nums.length - 1;
+ // 在 nums[left..right] 里查找 target 第一次出现的元素
  while (left < right) {
  int mid = (left + right) / 2;
+ // int mid = left + (right - left) / 2;
+ // int mid = (left + right) >>> 1;
  if (nums[mid] < target) {
+ // 小于一定不是解
  // mid 以及 mid 的左边一定不是目标元素第 1 次出现的位置
- // 下一轮搜索的区间是 [mid + 1, right]
+ // 下一轮搜索的区间是 [mid + 1..right]
  left = mid + 1;
  } else {
- // 下一轮搜索的区间是 [left, mid]
+ // 下一轮搜索的区间是 [left..mid]
  right = mid;
  }
  }
-
+ // 退出循环以后 left 与 right 重合
  if (nums[left] == target) {
  return left;
  }
  return -1;
  }
-}
+
+ private int searchLastPosition(int[] nums, int target) {
+ int left = 0;
+ int right = nums.length - 1;
+ while (left < right) {
+ int mid = (left + right + 1) / 2;
+ // int mid = left + (right - left + 1) / 2;
+ // int mid = (left + right + 1) >>> 1;
+ if (nums[mid] > target) {
+ // 大于一定不是解
+ // mid 以及 mid 的右边一定不是目标元素最后一次出现的位置
+ // 下一轮搜索的区间是 [left..mid - 1]
+ right = mid - 1;
+ } else {
+ // 下一轮搜索的区间是 [mid..right]
+ left = mid;
+ }
+ }
+ // 不用做特殊判断，能执行到这个方法，说明数组中一定存在 target
+ return left;
+ }
+}

02-Binary-Search/Type-1/0033-search-in-rotated-sorted-array/src/Solution4.java

@@ -2,30 +2,25 @@ public class Solution {
 
  public int searchInsert(int[] nums, int target) {
  int len = nums.length;
- // 题目没有说输入数组的长度可能为 0，因此需要做特殊判断
- if (len == 0) {
- return 0;
- }
-
+ // 特殊判断
  if (nums[len - 1] < target) {
  return len;
  }
+ // 程序走到这里一定有 target <= nums[len - 1]
  int left = 0;
  int right = len - 1;
-
- // 在区间 [left, right] 查找插入元素的位置
+ // 在区间 nums[left..right] 里查找第 1 个大于等于 target 的元素的下标
  while (left < right) {
  int mid = left + (right - left) / 2;
- if (nums[mid] < target){
- // 下一轮搜索的区间是 [mid + 1, right]
+ // 找 >= target 的第 1 个数
+ if (nums[mid] < target) {
+ // 下一轮搜索的区间 [mid + 1..right]
  left = mid + 1;
  } else {
- // 下一轮搜索的区间是 [left, mid]
+ // 下一轮搜索的区间是 [left..mid]
  right = mid;
  }
  }
- // 由于程序走到这里 [left, right] 里一定存在插入元素的位置
- // 且退出循环的时候一定有 left == right 成立，因此返回 left 或者 right 均可
  return left;
  }
 }