81.搜索旋转排序数组II，二分查找

Author: linwt

leetcode_Java/DoneTitle.txt

@@ -46,6 +46,7 @@
 77. 组合
 78. 子集
 79. 单词搜索
+81. 搜索旋转排序数组 II
 82. 删除排序链表中的重复元素 II
 83. 删除排序链表中的重复元素
 84. 柱状图中最大的矩形

leetcode_Java/DoneType.txt

@@ -170,6 +170,7 @@
 56. 合并区间（二维数组排序）
 59. 螺旋矩阵 II（四指针）
 75. 颜色分类（单指针，双指针）
+81. 搜索旋转排序数组 II（二分查找）
 88. 合并两个有序数组（排序，双指针）
 128. 最长连续序列（集合，排序）
 136. 只出现一次的数字（哈希表，列表，位运算）

leetcode_Java/Solution0033.java

@@ -21,8 +21,8 @@ public int search(int[] nums, int target) {
 二分查找：时间复杂度O(logn)
 1、左右索引求和除以2，得到中点索引，如果中点索引对应值为目标值，则返回中点索引
 2、在常规二分查找的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid-1] 和 [mid+1, r] 哪个部分是有序的，并判断 target 是否在有序的部分，从而决定改变二分查找的上下界
-  如果 [l, mid-1] 是有序数组，且 target 的大小满足 nums[left] <= target < nums[mid] ，则到 [l, mid-1]寻找，否则在 [mid+1, r] 寻找
-  如果 [mid+1, r] 是有序数组，且 target 的大小满足 nums[mid] < target <= nums[right]，则到 [mid+1, r]寻找，否则在 [l, mid-1] 寻找
+  如果 nums[left] < nums[mid]，那么左半部分 [l, mid-1] 是有序数组。如果 target 的大小满足 nums[left] <= target < nums[mid] ，则到 [l, mid-1]寻找，否则在 [mid+1, r] 寻找
+  如果 nums[left] > nums[mid]，那么右半部分 [mid+1, r] 是有序数组。如果 target 的大小满足 nums[mid] < target <= nums[right]，则到 [mid+1, r]寻找，否则在 [l, mid-1] 寻找
  */
 class Solution {
     public int search(int[] nums, int target) {
@@ -34,28 +34,26 @@ public int search(int[] nums, int target) {
             return nums[0] == target ? 0 : -1;
         }
         int left = 0, right = n - 1;
-        // 可能最后只剩下一个数要判断，所以需要等号
-        while (left <= right) {
-            int mid = (left + right) / 2;
-            if (nums[mid] == target) {
+        while (left <= right) {                 // 可能最后只剩下一个数要判断，所以需要等号
+            int mid = (left + right) / 2;       // (left + right + 1) / 2 也可以，因为中值判断过不满足就舍弃，所以不会存在重复中点死循环问题
+            if (nums[mid] == target) {          // 判断中点是否为目标值，是则返回中点
                 return mid;
             }
-            // 当剩下两个数时，left=mid，由于上面nums[mid]=nums[left]已经校验过不等于target，所以当前数要舍弃，期望左指针右移，所以需要等号，使if条件成立进入里面的逻辑
-            if (nums[left] <= nums[mid]) {  // 左半部分有序
-                // nums[left]还没判断过，所以需要等号。上面nums[mid]单独判断过了，所以不用等号。
-                if (nums[left] <= target && target < nums[mid]) {
-                    right = mid - 1;
-                } else {
-                    left = mid + 1;
+            // 当剩下两个数时，中点落在左边，由于上面已经校验过中值不等于目标值，所以当前数要舍弃，期望左指针右移，所以需要等号，使if条件成立进入里面的逻辑，让左指针右移
+            if (nums[left] <= nums[mid]) {                              // 左半部分有序
+                if (nums[left] <= target && target < nums[mid]) {       // 目标值在左半部分。[left,mid) 因为左值还没判断，中值已经判断过了
+                    right = mid - 1;                                    // 收缩右区间，中值已经判断过不满足了，不需要包含
+                } else {                                                // 目标值在右半部分
+                    left = mid + 1;                                     // 收缩左区间，中值已经判断过不满足了，不需要包含
                 }
-            } else {    // 右半部分有序
-                if (nums[mid] < target && target <= nums[right]) {
-                    left = mid + 1;
-                } else {
-                    right = mid - 1;
+            } else {                                                    // 右半部分有序
+                if (nums[mid] < target && target <= nums[right]) {      // 目标值在右半部分。(mid,right] 因为右值还没判断，中值已经判断过了
+                    left = mid + 1;                                     // 收缩左区间，中值已经判断过不满足了，不需要包含
+                } else {                                                // 目标值在左半部分
+                    right = mid - 1;                                    // 收缩右区间，中值已经判断过不满足了，不需要包含
                 }
             }
         }
-        return -1;
+        return -1;                                                      // 找不到返回-1
     }
 }

leetcode_Java/Solution0081.java

@@ -0,0 +1,43 @@
+// 81. 搜索旋转排序数组 II
+
+
+/*
+1、二分查找，比“33. 搜索旋转排序数组”多了重复元素
+2、二分的本质是「二段性」，并非单调性。只要一段满足某个性质，另外一段不满足某个性质，就可以用「二分」，再利用性质去判断选择收缩区间
+3、分类讨论举例
+  1）第一类：1011110111 和 1110111101。此种情况下 nums[start] == nums[mid]，分不清到底是前面有序还是后面有序，此时 left++ 即可，相当于去掉一个重复的干扰项
+  2）第二类：2345671。也就是 nums[left] < nums[mid]，此例子中就是 2 < 5，这种情况下，左半部分有序
+    因此如果 nums[left] <= target < nums[mid]，则在左半部分找，否则去右半部分找
+  3）第三类：6712345。也就是 nums[left] > nums[mid]，此例子中就是 6 > 2，这种情况下，右半部分有序
+    因此如果 nums[mid] < target <= nums[right]，则在右半部分找，否则去前半部分找
+ */
+class Solution {
+    public boolean search(int[] nums, int target) {
+        int n = nums.length;
+        int left = 0, right = n - 1;
+        while (left <= right) {               // 可能剩下最后一个数，也要判断是否为目标值，所以要等号
+            int mid = (left + right) / 2;     // (left + right + 1) / 2 也可以，因为中点值判断过不满足就舍弃，所以不会存在重复中点死循环问题
+            if (nums[mid] == target) {        // 判断中点是否为目标值，是则返回true
+                return true;
+            }
+            if (nums[left] == nums[mid]) {    // 由于存在重复元素，左值与中值相等时，无法区分二段性，让左指针右移，去掉一个重复的干扰项
+                left++;
+                continue;
+            }
+            if (nums[left] < nums[mid]) {                           // 左半部分有序。等号的情况上面已经判断了，这里就不用等号了
+                if (nums[left] <= target && target < nums[mid]) {   // 目标值在左半部分。[left,mid) 因为左值还没判断，中值已经判断过了
+                    right = mid - 1;                                // 收缩右区间，中值已经判断过不满足了，不需要包含
+                } else {                                            // 目标值在右半部分
+                    left = mid + 1;                                 // 收缩左区间，中值已经判断过不满足了，不需要包含
+                }
+            } else {                                                // 右半部分有序
+                if (nums[mid] < target && target <= nums[right]) {  // 目标值在右半部分。(mid,right] 因为右值还没判断，中值已经判断过了
+                    left = mid + 1;                                 // 收缩左区间，中值已经判断过不满足了，不需要包含
+                } else {                                            // 目标值在左半部分
+                    right = mid - 1;                                // 收缩右区间，中值已经判断过不满足了，不需要包含
+                }
+            }
+        }
+        return false;                                               // 没有找到目标值，返回false
+    }
+}