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

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

_{（回答开放以供审查/确认/更正措辞/计算当然，因为我试图整合不同的资源以得出在这种情况下有意义的理论）}