二刷81

Author: diguage

docs/0081-search-in-rotated-sorted-array-ii.adoc

@@ -1,74 +1,82 @@
 [#0081-search-in-rotated-sorted-array-ii]
-= 81. Search in Rotated Sorted Array II
+= 81. 搜索旋转排序数组 II
 
-{leetcode}/problems/search-in-rotated-sorted-array-ii/[LeetCode - Search in Rotated Sorted Array II^]
+https://leetcode.cn/problems/search-in-rotated-sorted-array-ii/[LeetCode - 81. 搜索旋转排序数组 II ^]
 
-Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+已知存在一个按非降序排列的整数数组 `+nums+` ，数组中的值不必互不相同。
 
-(i.e., `[0,0,1,2,2,5,6]` might become `[2,5,6,0,0,1,2]`).
+在传递给函数之前，`+nums+` 在预先未知的某个下标
+`+k+`（`+0 <= k < nums.length+`）上进行了 *旋转* ，使数组变为
+`+[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]+`（下标
+*从 0 开始* 计数）。例如， `+[0,1,2,4,4,4,5,6,6,7]+` 在下标 `+5+`
+处经旋转后可能变为 `+[4,5,6,6,7,0,1,2,4,4]+` 。
 
-You are given a target value to search. If found in the array return `true`, otherwise return `false`.
+给你 *旋转后* 的数组 `+nums+` 和一个整数 `+target+`
+，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 `+nums+`
+中存在这个目标值 `+target+` ，则返回 `+true+` ，否则返回 `+false+` 。
 
-.Example 1:
+你必须尽可能减少整个操作步骤。
+
+*示例 1：*
+
+[subs="verbatim,quotes,macros"]
 ----
-Input: nums = [2,5,6,0,0,1,2], target = 0
-Output: true
+输入：nums = [2,5,6,0,0,1,2], target = 0
+输出：true
 ----
 
-.Example 2:
+*示例 2：*
+
+[subs="verbatim,quotes,macros"]
 ----
-Input: nums = [2,5,6,0,0,1,2], target = 3
-Output: false
+输入：nums = [2,5,6,0,0,1,2], target = 3
+输出：false
 ----
 
+*提示：*
+
+* `+1 <= nums.length <= 5000+`
+* `-10`^`4`^`+<= nums[i] <= 10+`^`4`^
+* 题目数据保证 `nums` 在预先未知的某个下标上进行了旋转
+* `+-10+`^`4`^`+<= target <= 10+`^`+4+`^
+
 *Follow up:*
 
 * This is a follow up problem to xref:0033-search-in-rotated-sorted-array.adoc[33. Search in Rotated Sorted Array], where `nums` may contain duplicates.
 * Would this affect the run-time complexity? How and why?
 
+*进阶：*
+
+* 此题与 https://leetcode-cn.com/problems/search-in-rotated-sorted-array/description/[搜索旋转排序数组] 相似，但本题中的 `nums` 可能包含 *重复* 元素。这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
+
 == 解题思路
 
 这道题的关键是先确定哪部分有序，然后判断目标值是否在有序区间内，如果没有则再另外一部分内。
 
 另外，需要注意的就是对重复值的处理。如果左边的值和中间值相等，直接让左边下标向前移动一下，简单有效。
 
-== 参考资料
-
-. https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/zai-javazhong-ji-bai-liao-100de-yong-hu-by-reedfan/[搜索旋转排序数组 II - 搜索旋转排序数组 II - 力扣（LeetCode）^]
-
-Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
-
-(i.e., `[0,0,1,2,2,5,6]` might become `[2,5,6,0,0,1,2]`).
-
-You are given a target value to search. If found in the array return `true`, otherwise return `false`.
-
-*Example 1:*
-
-[subs="verbatim,quotes,macros"]
-----
-*Input:* nums = [2`,5,6,0,0,1,2]`, target = 0
-*Output:* true
 
+[[src-0081]]
+[tabs]
+====
+一刷::
++
+--
+[{java_src_attr}]
 ----
-
-*Example 2:*
-
-[subs="verbatim,quotes,macros"]
-----
-*Input:* nums = [2`,5,6,0,0,1,2]`, target = 3
-*Output:* false
+include::{sourcedir}/_0081_SearchInRotatedSortedArrayII.java[tag=answer]
 ----
+--
 
-*Follow up:*
-
-
-* This is a follow up problem to <a href="/problems/search-in-rotated-sorted-array/description/">Search in Rotated Sorted Array</a>, where `nums` may contain duplicates.
-* Would this affect the run-time complexity? How and why?
-
-
-[[src-0081]]
+二刷::
++
+--
 [{java_src_attr}]
 ----
-include::{sourcedir}/_0081_SearchInRotatedSortedArrayII.java[tag=answer]
+include::{sourcedir}/_0081_SearchInRotatedSortedArrayIi_2.java[tag=answer]
 ----
+--
+====
+
+== 参考资料
 

logbook/202503.adoc

@@ -16,20 +16,25 @@ endif::[]
 |⭕️ 递归解法非常妙！传一个参数，`next` 又 `next` 比较麻烦，传两个参数比较简单。
 
 |{counter:codes2503}
-|{leetcode_base_url}/find-first-and-last-position-of-element-in-sorted-array/[34. Find First and Last Position of Element in Sorted Array^]
+|{leetcode_base_url}/find-first-and-last-position-of-element-in-sorted-array/[34. 在排序数组中查找元素的第一个和最后一个位置^]
 |{doc_base_url}/0034-find-first-and-last-position-of-element-in-sorted-array.adoc[题解]
 |✅ 思考清楚确定边界时，中间指针的移动方向即可迎刃而解。
 
 |{counter:codes2503}
-|{leetcode_base_url}/search-in-rotated-sorted-array/[33. Search in Rotated Sorted Array^]
+|{leetcode_base_url}/search-in-rotated-sorted-array/[33. 搜索旋转排序数组^]
 |{doc_base_url}/0033-search-in-rotated-sorted-array.adoc[题解]
 |⭕️ 重点去处理有序部分，在有序部分内查找不到，则去另外一部分去查找。
 
 |{counter:codes2503}
-|{leetcode_base_url}/merge-intervals/[56. Merge Intervals^]
+|{leetcode_base_url}/merge-intervals/[56. 合并区间^]
 |{doc_base_url}/0056-merge-intervals.adoc[题解]
 |✅ 对区间进行排序，然后快慢指针在当前数组上对其进行合并。
 
+|{counter:codes2503}
+|{leetcode_base_url}/search-in-rotated-sorted-array-ii/[81. 搜索旋转排序数组 II^]
+|{doc_base_url}/0081-search-in-rotated-sorted-array-ii.adoc[题解]
+|✅ 关注有序区间，确定目标值在有序区间内，则在有序区间查找；反之，则在另外一部分内查找。另外，通过移动一个指针即可避开重复元素。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_0081_SearchInRotatedSortedArrayII.java

@@ -17,6 +17,9 @@ public class _0081_SearchInRotatedSortedArrayII {
      * Memory Usage: 38.6 MB, less than 88.73% of Java online submissions for Search in Rotated Sorted Array II.
      *
      * Copy from: https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/zai-javazhong-ji-bai-liao-100de-yong-hu-by-reedfan/[搜索旋转排序数组 II - 搜索旋转排序数组 II - 力扣（LeetCode）]
+     *
+     * @author D瓜哥 · https://www.diguage.com
+     * @since 2020-02-04 22:13
      */
     public boolean search(int[] nums, int target) {
         if (Objects.isNull(nums) || nums.length == 0) {

src/main/java/com/diguage/algo/leetcode/_0081_SearchInRotatedSortedArrayIi_2.java

@@ -0,0 +1,43 @@
+package com.diguage.algo.leetcode;
+
+public class _0081_SearchInRotatedSortedArrayIi_2 {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-03-06 14:46:31
+   */
+  public boolean search(int[] nums, int target) {
+    int left = 0, right = nums.length - 1;
+    while (left <= right) {
+      int mid = left + (right - left) / 2;
+      // 相等则直接返回
+      if (nums[mid] == target) {
+        return true;
+      }
+      if (nums[left] == nums[mid]) {
+        // 移动左指针，即可避开重复元素
+        left++;
+        continue;
+      }
+      if (nums[left] <= nums[mid]) {
+        //前面有序，且目标值在该区间内，则在有序部分内查找
+        if (nums[left] <= target && target < nums[mid]) {
+          right = mid - 1;
+        } else {
+          // 反之，则在无序区间内查找
+          left = mid + 1;
+        }
+      } else {
+        //后面有序，且目标值在该区间内，则在有序部分内查找
+        if (nums[mid] < target && target <= nums[right]) {
+          left = mid + 1;
+        } else {
+          // 反之，则在无序区间内查找
+          right = mid - 1;
+        }
+      }
+    }
+    return false;
+  }
+  // end::answer[]
+}