📖java

Author: Jstarfish

docs/.DS_Store

@@ -1 +1 @@
-Subproject commit e02f59de5d2afd19f5f9bde3a84cd808a20b3094
+Subproject commit 36ece2fca98c2db95ee0d83c9ab60dfde7ff51ed

docs/.vuepress/dist

@@ -3,12 +3,13 @@ title: 二分查找
 date: 2023-02-09
 tags: 
  - binary-search
+ - algorithms
 categories: algorithms
 ---
 
 ![](https://img.starfish.ink/algorithm/binary-search-banner.png)
 
-> 二分查找【折半查找】，一种简单高效的搜索算法，一般是利用有序数组的特性，通过逐步比较中间元素来快速定位目标值
+> 二分查找【折半查找】，一种简单高效的搜索算法，一般是利用有序数组的特性，通过逐步比较中间元素来快速定位目标值。
 >
 > 二分查找并不简单，Knuth 大佬（发明 KMP 算法的那位）都说二分查找：**思路很简单，细节是魔鬼**。比如二分查找让人头疼的细节问题，到底要给 `mid` 加一还是减一，while 里到底用 `<=` 还是 `<`。
 
@@ -68,7 +69,7 @@ int binarySearch(int[] nums, int target) {
 - 二分查找针对的是有序数组
 - 数据量太小太大都不是很适用二分（太小直接顺序遍历就够了，太大的话对连续内存空间要求更高）
 
-### [704. 二分查找](https://leetcode.cn/problems/binary-search/)（基本的二分搜索）
+### [二分查找『704』](https://leetcode.cn/problems/binary-search/)（基本的二分搜索）
 
 > 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
 >
@@ -95,6 +96,10 @@ int binarySearch(int[] nums, int target) {
 
 答：因为初始化 `right` 的赋值是 `nums.length - 1`，即最后一个元素的索引，而不是 `nums.length`。
 
+这二者可能出现在不同功能的二分查找中，区别是：前者相当于两端都闭区间 `[left, right]`，后者相当于左闭右开区间 `[left, right)`。因为索引大小为 `nums.length` 是越界的，所以我们把 `right` 这一边视为开区间。
+
+我们这个算法中使用的是前者 `[left, right]` 两端都闭的区间。**这个区间其实就是每次进行搜索的区间**。
+
 **2、为什么 `left = mid + 1`，`right = mid - 1`？我看有的代码是 `right = mid` 或者 `left = mid`，没有这些加加减减，到底怎么回事，怎么判断**？
 
 答：这也是二分查找的一个难点，不过只要你能理解前面的内容，就能够很容易判断。
@@ -103,7 +108,22 @@ int binarySearch(int[] nums, int target) {
 
 当然是去搜索区间 `[left, mid-1]` 或者区间 `[mid+1, right]` 对不对？**因为 `mid` 已经搜索过，应该从搜索区间中去除**。
 
-
+> ##### 1. **左闭右闭区间 `[left, right]`**
+>
+> - **循环条件**：`while (left <= right)`，因为 `left == right` 时区间仍有意义。
+> - 边界调整：
+>   - `nums[mid] < target` → `left = mid + 1`（排除 `mid` 左侧）
+>   - `nums[mid] > target` → `right = mid - 1`（排除 `mid` 右侧）
+> - 适用场景：明确目标值存在于数组时，直接返回下标。
+>
+> ##### 2. **左闭右开区间 `[left, right)`**
+>
+> - **初始化**：`right = nums.length`。
+> - **循环条件**：`while (left < right)`，因为 `left == right` 时区间为空。
+> - 边界调整：
+>   - `nums[mid] < target` → `left = mid + 1`
+>   - `nums[mid] > target` → `right = mid`（右开，不包含 `mid`）
+> - **适用场景**：需要处理目标值可能不在数组中的情况，例如插入位置问题
 
 > 比如说给你有序数组 `nums = [1,2,2,2,3]`，`target` 为 2，此算法返回的索引是 2，没错。但是如果我想得到 `target` 的左侧边界，即索引 1，或者我想得到 `target` 的右侧边界，即索引 3，这样的话此算法是无法处理的。
 >
@@ -112,7 +132,7 @@ int binarySearch(int[] nums, int target) {
 ### 寻找左侧边界的二分搜索
 
 ```java
-public static int leftBound(int[] nums, int target) {
+public int leftBound(int[] nums, int target) {
     int left = 0;
     int right = nums.length - 1;
     while (left <= right) {
@@ -122,7 +142,7 @@ public static int leftBound(int[] nums, int target) {
         } else if (nums[mid] < target) {
             left = mid + 1;
         } else {
-            //mid 是第一个元素，或者前一个元素不等于查找值，锁定
+            //mid 是第一个元素，或者前一个元素不等于查找值，锁定，且返回的是mid
             if (mid == 0 || nums[mid - 1] != target) return mid;
             else right = mid - 1;
         }
@@ -134,7 +154,7 @@ public static int leftBound(int[] nums, int target) {
 ### 寻找右侧边界的二分查找
 
 ```java
-public static int rightBound(int[] nums, int target){
+public int rightBound(int[] nums, int target){
     int left = 0;
     int right = nums.length - 1;
     while(left <= right){
@@ -174,99 +194,7 @@ public int firstNum(int[] nums, int target) {
 
 
 
-### [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/)
-
-> 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
-> 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]        若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
-> 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
-> 
->给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
-> 
->你必须设计一个时间复杂度为 $O(log n)$ 的算法解决此问题。
-> 
->```
-> 输入：nums = [3,4,5,1,2]
-> 输出：1
-> 解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
-> ```
-> 
->```
-> 输入：nums = [11,13,15,17]
-> 输出：11
-> 解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
-> ```
-
-**思路**：
-
-升序数组+旋转，仍然是部分有序，考虑用二分查找。
-
-![](https://assets.leetcode-cn.com/solution-static/153/1.png)
-
-> 我们先搞清楚题目中的数组是通过怎样的变化得来的，基本上就是等于将整个数组向右平移
-
-> 这种二分查找难就难在，arr[mid] 跟谁比。
->
-> 我们的目的是：当进行一次比较时，一定能够确定答案在 mid 的某一侧。一次比较为 arr[mid] 跟谁比的问题。
-> 一般的比较原则有：
->
-> - 如果有目标值 target，那么直接让 arr[mid] 和 target 比较即可。
-> - 如果没有目标值，一般可以考虑 **端点**
->
-> 如果中值 < 右值，则最小值在左半边，可以收缩右边界。
-> 如果中值 > 右值，则最小值在右半边，可以收缩左边界。
-
-旋转数组，最小值右侧的元素肯定都小于或等于数组中的最后一个元素 `nums[n-1]`，左侧元素都大于 `num[n-1]`
-
-```java
-public static int findMin(int[] nums) {
-  int left = 0;
-  int right = nums.length - 1;
-  //左闭右开
-  while (left < right) {
-    int mid = left + (right - left) / 2;
-    //疑问：为什么right = mid;而不是 right = mid-1;
-    //解答：{4,5,1,2,3}，如果right = mid-1，则丢失了最小值1
-    if (nums[mid] < nums[right]) {
-      right = mid;
-    } else {
-      left = mid + 1;
-    }
-  }
-  //循环结束条件，left = right，最小值输出nums[left]或nums[right]均可 
-  return nums[left];
-}
-```
-
-**如果是求旋转数组中的最大值呢**
-
-```java
-public static int findMax(int[] nums) {
-  int left = 0;
-  int right = nums.length - 1;
-
-  while (left < right) {
-    int mid = left + (right - left) >> 1;
-
-    //因为向下取整，left可能会等于mid，所以要考虑
-    if (nums[left] < nums[right]) {
-      return nums[right];
-    }
-
-    //[left,mid] 是递增的，最大值只会在[mid,right]中
-    if (nums[left] < nums[mid]) {
-      left = mid;
-    } else {
-      //[mid,right]递增，最大值只会在[left, mid-1]中
-      right = mid - 1;
-    }
-  }
-  return nums[left];
-}
-```
-
-
-
-### [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/)
+### [搜索旋转排序数组『33』](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/)
 
 > 整数数组 nums 按升序排列，数组中的值 互不相同 。
 >
@@ -297,14 +225,14 @@ public static int findMax(int[] nums) {
 public static int search(int[] nums,int target) {
       if(nums.length == 0) return -1;
       if(nums.length == 1) return target == nums[0] ? 0 : -1;
-      int left = 0;
-      int right = nums.length - 1;
+      int left = 0, right = nums.length - 1;
       while(left <= right){
           int mid = left + (right - left)/2;
           if(target == nums[mid]) return mid;
+        
           //左侧有序，注意是小于等于，处理最后只剩两个数的时候
-          if(nums[left] <= nums[mid]){
-              if(nums[left] <= target && target < nums[mid]){
+          if(nums[left] <= nums[mid]){  // 左半部分 [left..mid] 有序
+              if(nums[left] <= target && target < nums[mid]){ // target 在左半部分
                   right = mid - 1;
               }else{
                   left = mid + 1;
@@ -316,15 +244,14 @@ public static int search(int[] nums,int target) {
                   right = mid - 1;
               }
           }
-
       }
       return -1;
   }
 ```
 
 
 
-### [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
+### [在排序数组中查找元素的第一个和最后一个位置『34』](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
 
 > 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
 >
@@ -387,7 +314,97 @@ public int binarySearch(int[] nums, int target, boolean findLast) {
 
 
 
-### [287. 寻找重复数](https://leetcode-cn.com/problems/find-the-duplicate-number/)
+### [寻找旋转排序数组中的最小值『153』](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/)
+
+> 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
+> 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]        若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
+> 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
+> 
+>给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
+> 
+>你必须设计一个时间复杂度为 $O(log n)$ 的算法解决此问题。
+> 
+>```
+> 输入：nums = [3,4,5,1,2]
+> 输出：1
+> 解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
+> ```
+> 
+>```
+> 输入：nums = [11,13,15,17]
+> 输出：11
+> 解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
+> ```
+
+**思路**：
+
+升序数组+旋转，仍然是部分有序，考虑用二分查找。
+
+![](https://assets.leetcode-cn.com/solution-static/153/1.png)
+
+> 我们先搞清楚题目中的数组是通过怎样的变化得来的，基本上就是等于将整个数组向右平移
+
+> 这种二分查找难就难在，arr[mid] 跟谁比。
+>
+> 我们的目的是：当进行一次比较时，一定能够确定答案在 mid 的某一侧。一次比较为 arr[mid] 跟谁比的问题。
+> 一般的比较原则有：
+>
+> - 如果有目标值 target，那么直接让 arr[mid] 和 target 比较即可。
+> - 如果没有目标值，一般可以考虑 **端点**
+>
+> 如果中值 < 右值，则最小值在左半边，可以收缩右边界。
+> 如果中值 > 右值，则最小值在右半边，可以收缩左边界。
+
+旋转数组，最小值右侧的元素肯定都小于或等于数组中的最后一个元素 `nums[n-1]`，左侧元素都大于 `num[n-1]`
+
+```java
+public static int findMin(int[] nums) {
+  int left = 0;
+  int right = nums.length - 1;
+  //左闭右开
+  while (left < right) {
+    int mid = left + (right - left) / 2;
+    //疑问：为什么right = mid;而不是 right = mid-1;
+    //解答：{4,5,1,2,3}，如果right = mid-1，则丢失了最小值1
+    if (nums[mid] < nums[right]) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+  //循环结束条件，left = right，最小值输出nums[left]或nums[right]均可 
+  return nums[left];
+}
+```
+
+**如果是求旋转数组中的最大值呢**
+
+```java
+public static int findMax(int[] nums) {
+  int left = 0;
+  int right = nums.length - 1;
+
+  while (left < right) {
+    int mid = left + (right - left) >> 1;
+
+    //因为向下取整，left可能会等于mid，所以要考虑
+    if (nums[left] < nums[right]) {
+      return nums[right];
+    }
+
+    //[left,mid] 是递增的，最大值只会在[mid,right]中
+    if (nums[left] < nums[mid]) {
+      left = mid;
+    } else {
+      //[mid,right]递增，最大值只会在[left, mid-1]中
+      right = mid - 1;
+    }
+  }
+  return nums[left];
+}
+```
+
+### [寻找重复数『287』](https://leetcode-cn.com/problems/find-the-duplicate-number/)
 
 > 给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。
 >
@@ -446,7 +463,7 @@ public int findDuplicate(int[] nums) {
 
 
 
-### [162. 寻找峰值](https://leetcode-cn.com/problems/find-peak-element/)
+### [寻找峰值『162』](https://leetcode-cn.com/problems/find-peak-element/)
 
 > 峰值元素是指其值严格大于左右相邻值的元素。
 >
@@ -511,7 +528,7 @@ public int findPeakElement(int[] nums) {
 
 
 
-### [240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/)
+### [搜索二维矩阵 II『240』](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/)
 
 > [剑指 Offer 04. 二维数组中的查找](https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/) 一样的题目
 >
@@ -555,7 +572,7 @@ public int findPeakElement(int[] nums) {
 
 
 
-### [35. 搜索插入位置](https://leetcode.cn/problems/search-insert-position/)
+### [搜索插入位置『35』](https://leetcode.cn/problems/search-insert-position/)
 
 > 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 `O(log n)` 的算法。
 >
@@ -588,7 +605,7 @@ public int searchInsert(int[] nums, int target) {
 
 
 
-### [300. 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence/)
+### [最长递增子序列『300』](https://leetcode.cn/problems/longest-increasing-subsequence/)
 
 > 给你一个整数数组 `nums` ，找到其中最长严格递增子序列的长度。
 >
@@ -606,7 +623,7 @@ public int searchInsert(int[] nums, int target) {
 
 
 
-### [4. 寻找两个正序数组的中位数](https://leetcode.cn/problems/median-of-two-sorted-arrays/)
+### [寻找两个正序数组的中位数『4』](https://leetcode.cn/problems/median-of-two-sorted-arrays/)
 
 > 给定两个大小分别为 `m` 和 `n` 的正序（从小到大）数组 `nums1` 和 `nums2`。请你找出并返回这两个正序数组的 **中位数** 。
 >

docs/data-structure-algorithms/.DS_Store

@@ -107,7 +107,7 @@ categories: BFS DFS
 
 **重要性质**
 
-  根据定义不难得到以下性质。
+根据定义不难得到以下性质。
 
   - 性质 1：二叉树的 前序遍历 序列，根结点一定是 最先 访问到的结点；
   - 性质 2：二叉树的 后序遍历 序列，根结点一定是 最后 访问到的结点；
@@ -625,4 +625,3 @@ public void bfsGraph(Map<Integer, List<Integer>> graph, int start) {
 ## Reference
 
 - https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/bfs-de-shi-yong-chang-jing-zong-jie-ceng-xu-bian-l/
-