--- comments: true --- # 10.3 二分搜尋邊界 ## 10.3.1 查詢左邊界 !!! question 給定一個長度為 $n$ 的有序陣列 `nums` ，其中可能包含重複元素。請返回陣列中最左一個元素 `target` 的索引。若陣列中不包含該元素，則返回 $-1$ 。回憶二分搜尋插入點的方法，搜尋完成後 $i$ 指向最左一個 `target` ，**因此查詢插入點本質上是在查詢最左一個 `target` 的索引**。考慮透過查詢插入點的函式實現查詢左邊界。請注意，陣列中可能不包含 `target` ，這種情況可能導致以下兩種結果。 - 插入點的索引 $i$ 越界。 - 元素 `nums[i]` 與 `target` 不相等。當遇到以上兩種情況時，直接返回 $-1$ 即可。程式碼如下所示： === "Python" ```python title="binary_search_edge.py" def binary_search_left_edge(nums: list[int], target: int) -> int: """二分搜尋最左一個 target""" # 等價於查詢 target 的插入點 i = binary_search_insertion(nums, target) # 未找到 target ，返回 -1 if i == len(nums) or nums[i] != target: return -1 # 找到 target ，返回索引 i return i ``` === "C++" ```cpp title="binary_search_edge.cpp" /* 二分搜尋最左一個 target */ int binarySearchLeftEdge(vector &nums, int target) { // 等價於查詢 target 的插入點 int i = binarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i == nums.size() || nums[i] != target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "Java" ```java title="binary_search_edge.java" /* 二分搜尋最左一個 target */ int binarySearchLeftEdge(int[] nums, int target) { // 等價於查詢 target 的插入點 int i = binary_search_insertion.binarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i == nums.length || nums[i] != target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "C#" ```csharp title="binary_search_edge.cs" /* 二分搜尋最左一個 target */ int BinarySearchLeftEdge(int[] nums, int target) { // 等價於查詢 target 的插入點 int i = binary_search_insertion.BinarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i == nums.Length || nums[i] != target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "Go" ```go title="binary_search_edge.go" /* 二分搜尋最左一個 target */ func binarySearchLeftEdge(nums []int, target int) int { // 等價於查詢 target 的插入點 i := binarySearchInsertion(nums, target) // 未找到 target ，返回 -1 if i == len(nums) || nums[i] != target { return -1 } // 找到 target ，返回索引 i return i } ``` === "Swift" ```swift title="binary_search_edge.swift" /* 二分搜尋最左一個 target */ func binarySearchLeftEdge(nums: [Int], target: Int) -> Int { // 等價於查詢 target 的插入點 let i = binarySearchInsertion(nums: nums, target: target) // 未找到 target ，返回 -1 if i == nums.endIndex || nums[i] != target { return -1 } // 找到 target ，返回索引 i return i } ``` === "JS" ```javascript title="binary_search_edge.js" /* 二分搜尋最左一個 target */ function binarySearchLeftEdge(nums, target) { // 等價於查詢 target 的插入點 const i = binarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i === nums.length || nums[i] !== target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "TS" ```typescript title="binary_search_edge.ts" /* 二分搜尋最左一個 target */ function binarySearchLeftEdge(nums: Array, target: number): number { // 等價於查詢 target 的插入點 const i = binarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i === nums.length || nums[i] !== target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "Dart" ```dart title="binary_search_edge.dart" /* 二分搜尋最左一個 target */ int binarySearchLeftEdge(List nums, int target) { // 等價於查詢 target 的插入點 int i = binarySearchInsertion(nums, target); // 未找到 target ，返回 -1 if (i == nums.length || nums[i] != target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "Rust" ```rust title="binary_search_edge.rs" /* 二分搜尋最左一個 target */ fn binary_search_left_edge(nums: &[i32], target: i32) -> i32 { // 等價於查詢 target 的插入點 let i = binary_search_insertion(nums, target); // 未找到 target ，返回 -1 if i == nums.len() as i32 || nums[i as usize] != target { return -1; } // 找到 target ，返回索引 i i } ``` === "C" ```c title="binary_search_edge.c" /* 二分搜尋最左一個 target */ int binarySearchLeftEdge(int *nums, int numSize, int target) { // 等價於查詢 target 的插入點 int i = binarySearchInsertion(nums, numSize, target); // 未找到 target ，返回 -1 if (i == numSize || nums[i] != target) { return -1; } // 找到 target ，返回索引 i return i; } ``` === "Kotlin" ```kotlin title="binary_search_edge.kt" /* 二分搜尋最左一個 target */ fun binarySearchLeftEdge(nums: IntArray, target: Int): Int { // 等價於查詢 target 的插入點 val i = binarySearchInsertion(nums, target) // 未找到 target ，返回 -1 if (i == nums.size || nums[i] != target) { return -1 } // 找到 target ，返回索引 i return i } ``` === "Ruby" ```ruby title="binary_search_edge.rb" ### 二分搜尋最左一個 target ### def binary_search_left_edge(nums, target) # 等價於查詢 target 的插入點 i = binary_search_insertion(nums, target) # 未找到 target ，返回 -1 return -1 if i == nums.length || nums[i] != target i # 找到 target ，返回索引 i end ``` === "Zig" ```zig title="binary_search_edge.zig" [class]{}-[func]{binarySearchLeftEdge} ``` ??? pythontutor "視覺化執行"

## 10.3.2 查詢右邊界那麼如何查詢最右一個 `target` 呢？最直接的方式是修改程式碼，替換在 `nums[m] == target` 情況下的指標收縮操作。程式碼在此省略，有興趣的讀者可以自行實現。下面我們介紹兩種更加取巧的方法。 ### 1. 複用查詢左邊界實際上，我們可以利用查詢最左元素的函式來查詢最右元素，具體方法為：**將查詢最右一個 `target` 轉化為查詢最左一個 `target + 1`**。如圖 10-7 所示，查詢完成後，指標 $i$ 指向最左一個 `target + 1`（如果存在），而 $j$ 指向最右一個 `target` ，**因此返回 $j$ 即可**。 ![將查詢右邊界轉化為查詢左邊界](binary_search_edge.assets/binary_search_right_edge_by_left_edge.png){ class="animation-figure" }

圖 10-7 將查詢右邊界轉化為查詢左邊界

請注意，返回的插入點是 $i$ ，因此需要將其減 $1$ ，從而獲得 $j$ ： === "Python" ```python title="binary_search_edge.py" def binary_search_right_edge(nums: list[int], target: int) -> int: """二分搜尋最右一個 target""" # 轉化為查詢最左一個 target + 1 i = binary_search_insertion(nums, target + 1) # j 指向最右一個 target ，i 指向首個大於 target 的元素 j = i - 1 # 未找到 target ，返回 -1 if j == -1 or nums[j] != target: return -1 # 找到 target ，返回索引 j return j ``` === "C++" ```cpp title="binary_search_edge.cpp" /* 二分搜尋最右一個 target */ int binarySearchRightEdge(vector &nums, int target) { // 轉化為查詢最左一個 target + 1 int i = binarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 int j = i - 1; // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "Java" ```java title="binary_search_edge.java" /* 二分搜尋最右一個 target */ int binarySearchRightEdge(int[] nums, int target) { // 轉化為查詢最左一個 target + 1 int i = binary_search_insertion.binarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 int j = i - 1; // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "C#" ```csharp title="binary_search_edge.cs" /* 二分搜尋最右一個 target */ int BinarySearchRightEdge(int[] nums, int target) { // 轉化為查詢最左一個 target + 1 int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 int j = i - 1; // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "Go" ```go title="binary_search_edge.go" /* 二分搜尋最右一個 target */ func binarySearchRightEdge(nums []int, target int) int { // 轉化為查詢最左一個 target + 1 i := binarySearchInsertion(nums, target+1) // j 指向最右一個 target ，i 指向首個大於 target 的元素 j := i - 1 // 未找到 target ，返回 -1 if j == -1 || nums[j] != target { return -1 } // 找到 target ，返回索引 j return j } ``` === "Swift" ```swift title="binary_search_edge.swift" /* 二分搜尋最右一個 target */ func binarySearchRightEdge(nums: [Int], target: Int) -> Int { // 轉化為查詢最左一個 target + 1 let i = binarySearchInsertion(nums: nums, target: target + 1) // j 指向最右一個 target ，i 指向首個大於 target 的元素 let j = i - 1 // 未找到 target ，返回 -1 if j == -1 || nums[j] != target { return -1 } // 找到 target ，返回索引 j return j } ``` === "JS" ```javascript title="binary_search_edge.js" /* 二分搜尋最右一個 target */ function binarySearchRightEdge(nums, target) { // 轉化為查詢最左一個 target + 1 const i = binarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 const j = i - 1; // 未找到 target ，返回 -1 if (j === -1 || nums[j] !== target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "TS" ```typescript title="binary_search_edge.ts" /* 二分搜尋最右一個 target */ function binarySearchRightEdge(nums: Array, target: number): number { // 轉化為查詢最左一個 target + 1 const i = binarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 const j = i - 1; // 未找到 target ，返回 -1 if (j === -1 || nums[j] !== target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "Dart" ```dart title="binary_search_edge.dart" /* 二分搜尋最右一個 target */ int binarySearchRightEdge(List nums, int target) { // 轉化為查詢最左一個 target + 1 int i = binarySearchInsertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 int j = i - 1; // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "Rust" ```rust title="binary_search_edge.rs" /* 二分搜尋最右一個 target */ fn binary_search_right_edge(nums: &[i32], target: i32) -> i32 { // 轉化為查詢最左一個 target + 1 let i = binary_search_insertion(nums, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 let j = i - 1; // 未找到 target ，返回 -1 if j == -1 || nums[j as usize] != target { return -1; } // 找到 target ，返回索引 j j } ``` === "C" ```c title="binary_search_edge.c" /* 二分搜尋最右一個 target */ int binarySearchRightEdge(int *nums, int numSize, int target) { // 轉化為查詢最左一個 target + 1 int i = binarySearchInsertion(nums, numSize, target + 1); // j 指向最右一個 target ，i 指向首個大於 target 的元素 int j = i - 1; // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1; } // 找到 target ，返回索引 j return j; } ``` === "Kotlin" ```kotlin title="binary_search_edge.kt" /* 二分搜尋最右一個 target */ fun binarySearchRightEdge(nums: IntArray, target: Int): Int { // 轉化為查詢最左一個 target + 1 val i = binarySearchInsertion(nums, target + 1) // j 指向最右一個 target ，i 指向首個大於 target 的元素 val j = i - 1 // 未找到 target ，返回 -1 if (j == -1 || nums[j] != target) { return -1 } // 找到 target ，返回索引 j return j } ``` === "Ruby" ```ruby title="binary_search_edge.rb" ### 二分搜尋最右一個 target ### def binary_search_right_edge(nums, target) # 轉化為查詢最左一個 target + 1 i = binary_search_insertion(nums, target + 1) # j 指向最右一個 target ，i 指向首個大於 target 的元素 j = i - 1 # 未找到 target ，返回 -1 return -1 if j == -1 || nums[j] != target j # 找到 target ，返回索引 j end ``` === "Zig" ```zig title="binary_search_edge.zig" [class]{}-[func]{binarySearchRightEdge} ``` ??? pythontutor "視覺化執行"

全螢幕觀看 >

### 2. 轉化為查詢元素我們知道，當陣列不包含 `target` 時，最終 $i$ 和 $j$ 會分別指向首個大於、小於 `target` 的元素。因此，如圖 10-8 所示，我們可以構造一個陣列中不存在的元素，用於查詢左右邊界。 - 查詢最左一個 `target` ：可以轉化為查詢 `target - 0.5` ，並返回指標 $i$ 。 - 查詢最右一個 `target` ：可以轉化為查詢 `target + 0.5` ，並返回指標 $j$ 。 ![將查詢邊界轉化為查詢元素](binary_search_edge.assets/binary_search_edge_by_element.png){ class="animation-figure" }

圖 10-8 將查詢邊界轉化為查詢元素

程式碼在此省略，以下兩點值得注意。 - 給定陣列不包含小數，這意味著我們無須關心如何處理相等的情況。 - 因為該方法引入了小數，所以需要將函式中的變數 `target` 改為浮點數型別（Python 無須改動）。