12.2 分治搜尋策略¶

我們已經學過，搜尋演算法分為兩大類。

暴力搜尋：它透過走訪資料結構實現，時間複雜度為 \(O(n)\) 。
自適應搜尋：它利用特有的資料組織形式或先驗資訊，時間複雜度可達到 \(O(\log n)\) 甚至 \(O(1)\) 。

實際上，時間複雜度為 \(O(\log n)\) 的搜尋演算法通常是基於分治策略實現的，例如二分搜尋和樹。

二分搜尋的每一步都將問題（在陣列中搜索目標元素）分解為一個小問題（在陣列的一半中搜索目標元素），這個過程一直持續到陣列為空或找到目標元素為止。
樹是分治思想的代表，在二元搜尋樹、AVL 樹、堆積等資料結構中，各種操作的時間複雜度皆為 \(O(\log n)\) 。

二分搜尋的分治策略如下所示。

問題可以分解：二分搜尋遞迴地將原問題（在陣列中進行查詢）分解為子問題（在陣列的一半中進行查詢），這是透過比較中間元素和目標元素來實現的。
子問題是獨立的：在二分搜尋中，每輪只處理一個子問題，它不受其他子問題的影響。
子問題的解無須合併：二分搜尋旨在查詢一個特定元素，因此不需要將子問題的解進行合併。當子問題得到解決時，原問題也會同時得到解決。

分治能夠提升搜尋效率，本質上是因為暴力搜尋每輪只能排除一個選項，而分治搜尋每輪可以排除一半選項。

1. 基於分治實現二分搜尋¶

在之前的章節中，二分搜尋是基於遞推（迭代）實現的。現在我們基於分治（遞迴）來實現它。

Question

給定一個長度為 \(n\) 的有序陣列 nums ，其中所有元素都是唯一的，請查詢元素 target 。

從分治角度，我們將搜尋區間 \([i, j]\) 對應的子問題記為 \(f(i, j)\) 。

以原問題 \(f(0, n-1)\) 為起始點，透過以下步驟進行二分搜尋。

計算搜尋區間 \([i, j]\) 的中點 \(m\) ，根據它排除一半搜尋區間。
遞迴求解規模減小一半的子問題，可能為 \(f(i, m-1)\) 或 \(f(m+1, j)\) 。
迴圈第 1. 步和第 2. 步，直至找到 target 或區間為空時返回。

圖 12-4 展示了在陣列中二分搜尋元素 \(6\) 的分治過程。

圖 12-4 二分搜尋的分治過程

在實現程式碼中，我們宣告一個遞迴函式 dfs() 來求解問題 \(f(i, j)\) ：

PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig

binary_search_recur.py

def dfs(nums: list[int], target: int, i: int, j: int) -> int:
    """二分搜尋：問題 f(i, j)"""
    # 若區間為空，代表無目標元素，則返回 -1
    if i > j:
        return -1
    # 計算中點索引 m
    m = (i + j) // 2
    if nums[m] < target:
        # 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j)
    elif nums[m] > target:
        # 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1)
    else:
        # 找到目標元素，返回其索引
        return m

def binary_search(nums: list[int], target: int) -> int:
    """二分搜尋"""
    n = len(nums)
    # 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1)

binary_search_recur.cpp

/* 二分搜尋：問題 f(i, j) */
int dfs(vector<int> &nums, int target, int i, int j) {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    int m = (i + j) / 2;
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
int binarySearch(vector<int> &nums, int target) {
    int n = nums.size();
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1);
}

binary_search_recur.java

/* 二分搜尋：問題 f(i, j) */
int dfs(int[] nums, int target, int i, int j) {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    int m = (i + j) / 2;
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
int binarySearch(int[] nums, int target) {
    int n = nums.length;
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1);
}

binary_search_recur.cs

/* 二分搜尋：問題 f(i, j) */
int DFS(int[] nums, int target, int i, int j) {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    int m = (i + j) / 2;
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return DFS(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return DFS(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
int BinarySearch(int[] nums, int target) {
    int n = nums.Length;
    // 求解問題 f(0, n-1)
    return DFS(nums, target, 0, n - 1);
}

binary_search_recur.go

/* 二分搜尋：問題 f(i, j) */
func dfs(nums []int, target, i, j int) int {
    // 如果區間為空，代表沒有目標元素，則返回 -1
    if i > j {
        return -1
    }
    //    計算索引中點
    m := i + ((j - i) >> 1)
    //判斷中點與目標元素大小
    if nums[m] < target {
        // 小於則遞迴右半陣列
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m+1, j)
    } else if nums[m] > target {
        // 小於則遞迴左半陣列
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m-1)
    } else {
        // 找到目標元素，返回其索引
        return m
    }
}

/* 二分搜尋 */
func binarySearch(nums []int, target int) int {
    n := len(nums)
    return dfs(nums, target, 0, n-1)
}

binary_search_recur.swift

/* 二分搜尋：問題 f(i, j) */
func dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {
    // 若區間為空，代表無目標元素，則返回 -1
    if i > j {
        return -1
    }
    // 計算中點索引 m
    let m = (i + j) / 2
    if nums[m] < target {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums: nums, target: target, i: m + 1, j: j)
    } else if nums[m] > target {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums: nums, target: target, i: i, j: m - 1)
    } else {
        // 找到目標元素，返回其索引
        return m
    }
}

/* 二分搜尋 */
func binarySearch(nums: [Int], target: Int) -> Int {
    // 求解問題 f(0, n-1)
    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)
}

binary_search_recur.js

/* 二分搜尋：問題 f(i, j) */
function dfs(nums, target, i, j) {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    const m = i + ((j - i) >> 1);
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
function binarySearch(nums, target) {
    const n = nums.length;
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1);
}

binary_search_recur.ts

/* 二分搜尋：問題 f(i, j) */
function dfs(nums: number[], target: number, i: number, j: number): number {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    const m = i + ((j - i) >> 1);
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
function binarySearch(nums: number[], target: number): number {
    const n = nums.length;
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1);
}

binary_search_recur.dart

/* 二分搜尋：問題 f(i, j) */
int dfs(List<int> nums, int target, int i, int j) {
  // 若區間為空，代表無目標元素，則返回 -1
  if (i > j) {
    return -1;
  }
  // 計算中點索引 m
  int m = (i + j) ~/ 2;
  if (nums[m] < target) {
    // 遞迴子問題 f(m+1, j)
    return dfs(nums, target, m + 1, j);
  } else if (nums[m] > target) {
    // 遞迴子問題 f(i, m-1)
    return dfs(nums, target, i, m - 1);
  } else {
    // 找到目標元素，返回其索引
    return m;
  }
}

/* 二分搜尋 */
int binarySearch(List<int> nums, int target) {
  int n = nums.length;
  // 求解問題 f(0, n-1)
  return dfs(nums, target, 0, n - 1);
}

binary_search_recur.rs

/* 二分搜尋：問題 f(i, j) */
fn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {
    // 若區間為空，代表無目標元素，則返回 -1
    if i > j {
        return -1;
    }
    let m: i32 = (i + j) / 2;
    if nums[m as usize] < target {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if nums[m as usize] > target {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
fn binary_search(nums: &[i32], target: i32) -> i32 {
    let n = nums.len() as i32;
    // 求解問題 f(0, n-1)
    dfs(nums, target, 0, n - 1)
}

binary_search_recur.c

/* 二分搜尋：問題 f(i, j) */
int dfs(int nums[], int target, int i, int j) {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1;
    }
    // 計算中點索引 m
    int m = (i + j) / 2;
    if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        return dfs(nums, target, m + 1, j);
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        return dfs(nums, target, i, m - 1);
    } else {
        // 找到目標元素，返回其索引
        return m;
    }
}

/* 二分搜尋 */
int binarySearch(int nums[], int target, int numsSize) {
    int n = numsSize;
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1);
}

binary_search_recur.kt

/* 二分搜尋：問題 f(i, j) */
fun dfs(
    nums: IntArray,
    target: Int,
    i: Int,
    j: Int
): Int {
    // 若區間為空，代表無目標元素，則返回 -1
    if (i > j) {
        return -1
    }
    // 計算中點索引 m
    val m = (i + j) / 2
    return if (nums[m] < target) {
        // 遞迴子問題 f(m+1, j)
        dfs(nums, target, m + 1, j)
    } else if (nums[m] > target) {
        // 遞迴子問題 f(i, m-1)
        dfs(nums, target, i, m - 1)
    } else {
        // 找到目標元素，返回其索引
        m
    }
}

/* 二分搜尋 */
fun binarySearch(nums: IntArray, target: Int): Int {
    val n = nums.size
    // 求解問題 f(0, n-1)
    return dfs(nums, target, 0, n - 1)
}

binary_search_recur.rb

[class]{}-[func]{dfs}

[class]{}-[func]{binary_search}

binary_search_recur.zig

[class]{}-[func]{dfs}

[class]{}-[func]{binarySearch}

視覺化執行

全螢幕觀看 >