如何找到二分搜索算法的迭代次數？

Question

如何獲得二分搜索的迭代次數？

這是我的代碼：

int main() 
{
    int target = 11;
    int N = 10;
    std::vector<int> index;
    int num;

    for (int i = 0; i < N; i++) {
        index.push_back(i);
    }

    int counter = 0;
    unsigned int M, L = (unsigned int)-1, R = N;

    M = (R - L) / 2;  // Assume N is not zero

    do {
        int value;
        M = M + L;
        value = index[M];
        if (value < target) L = M; else R = M;
        M = (R - L) / 2;
        counter++;
    } while (M);  // M is the size of the current interval

    std::cout << R << '\n';
    std::cout << "counter: " << counter << '\n';

    system("pause");

    return 0;
}

我想知道取決於N的迭代次數。 我知道這個算法是如何工作的，但我想要以數學方式表示的迭代次數。

Answer 1

我會通過使用遞歸二進制搜索函數來進行遞歸增量。 在二進制檢查的每個分支中，只需遞增 1 即可遞歸計算迭代次數。

在這里看直播

#include <iostream>
#include <vector>

std::size_t binarySearch(
    const std::vector<int>& arr,        // pass array as non-modifiyable(const ref)
    std::size_t start, std::size_t end, // start and end indexes of the array
    const int target)                   // target to find
{
    if (arr.size() == 1) return arr[0] == target ? 1 : 0; // edge case

    if (start <= end)
    {
        const std::size_t mid_index = start + ((end - start) / 2);
        return arr[mid_index] == target ? 1 :                         // found the middle element
               arr[mid_index] < target ?
                 binarySearch(arr, mid_index + 1, end, target) + 1:   // target is greater than mid-element
                 binarySearch(arr, start, mid_index - 1, target) + 1; // target is less than mid-element
    }
    return 0;
}

int main()
{
    int target = 11;
    const int N = 10;
    std::vector<int> index;
    index.reserve(N); // reserve some memory
    for (int i = 0; i < N; i++) {
        index.push_back(i);
    }
    std::cout << "counter: " << binarySearch(index, 0, index.size() - 1, target) << std::endl;
    return 0;
}

輸出：

counter: 4

Answer 2

數學上可能的最大迭代（假設只有整數類型的情況）是 = ceil( log2 ( initial_r - initial_l ) ) 對數的基數是 2 因為每次我們通過取一個中間值並切換到一半來將我們的范圍減半。

Answer 3

我也一直試圖圍繞對數概念化進行思考，這就是我試圖理解答案的方式

來自https://en.wikipedia.org/wiki/Binary_search_algorithm

在數學中，二進制對數 (log ₂ n) 是數字 2 必須進行的冪才能獲得值 n。 也就是說，對於任何實數 x，
x=log ₂ n <=等價於=> 2 ^x =n

&

每棵有 n 個葉子的二叉樹的高度至少為 log ₂ n，當 n 是 > 2 的冪並且這棵樹是一棵完全二叉樹時相等。

二分搜索有點像沿着二叉搜索樹走，然后將節點減半，該系列是對數（以 2 為底）系列_{（我自己的理解，沒有引用，可能是錯誤的）}

然后從https://www.cct.lsu.edu/~sidhanti/tutorials/data_structures/page305.html

高度為 h 的完美二叉樹正好有 2 ^h+1 -1 個內部節點。 相反，具有 n 個內部節點的完美二叉樹的高度為 log ₂ (n+1)。 如果我們有一個具有完美二叉樹形狀的搜索樹，那么每次不成功的搜索都會訪問恰好 h+1 個內部節點，其中 h=log ₂ (n+1)。

_{（再次跟進我自己的理解......）}
因此，要到達節點 N（每個二叉搜索樹的值為 N？），在最壞的情況下，您將進行 log ₂ (N+1) 次迭代（遍歷樹的多個級別）（找到仍然是一個概率，因此“最壞情況”的措辭）。

在這里試運行（通過構建一個小的 BST 並手動計數）： https : //www.cs.usfca.edu/~galles/visualization/BST.html

_{（回答開放以供審查/確認/更正措辭/計算當然，因為我試圖整合不同的資源以得出在這種情況下有意義的理論）}