无所不在的二进制搜索|套装1

我们都知道二进制搜索算法。二进制搜索是最简单的难解决的算法。我提出了一些我在二进制搜索中收集到的有趣问题。二进制搜索有一些要求。

我要求您遵守“我真诚地尝试解决问题并确保没有极端情况”的准则。阅读完每个问题后，请最小化浏览器并尝试解决它。

问题陈述：给定N个不同元素的排序数组。使用最少数量的比较在数组中找到一个键。 (您认为二进制搜索最适合在排序数组中搜索键吗?)

没有太多的理论，这是典型的二进制搜索算法。

// Returns location of key, or -1 if not found
int BinarySearch(int A[], int l, int r, int key)
{
    int m;
  
    while( l <= r )
    {
        m = l + (r-l)/2;
  
        if( A[m] == key ) // first comparison
            return m;
  
        if( A[m] < key ) // second comparison
            l = m + 1;
        else
            r = m - 1;
    }
  
    return -1;
}

理论上，在最坏的情况下，我们需要log N +1个比较。如果我们观察到的话，那么每次迭代都将使用两次比较，除非最终成功匹配(如果有)。在实践中，比较将是昂贵的操作，而不仅仅是原始类型比较。将比较最小化为理论极限值比较经济。

在下一个实现中，请参见下图有关索引初始化的图。

以下实现使用较少数量的比较。

// Invariant: A[l] <= key and A[r] > key
// Boundary: |r - l| = 1
// Input: A[l .... r-1]
int BinarySearch(int A[], int l, int r, int key)
{
    int m;
  
    while( r - l > 1 )
    {
        m = l + (r-l)/2;
  
        if( A[m] <= key )
            l = m;
        else
            r = m;
    }
  
    if( A[l] == key )
        return l;
    if( A[r] == key )
        return r;
    else
        return -1;
}

在while循环中，我们仅取决于一个比较。搜索空间收敛以放置l和r指向两个不同的连续元素。我们需要再进行一次比较以跟踪搜索状态。

您可以看到示例测试用例http://ideone.com/76bad0。 ( C++ 11代码)

问题陈述：给定一个由N个不同整数组成的数组，找到输入“键”的下限值。假设A = {-1、2、3、5、6、8、9、10}，并且key = 7，我们应该返回6作为结果。

我们可以使用以上优化的实现来找到密钥的底值。只要不变量保持不变，我们就会一直将左指针移到最右端。最终，左指针指向一个小于或等于键的元素(根据定义的下限值)。以下是可能的极端情况，

—>如果数组中的所有元素都小于键，则左指针移动到最后一个元素。

—>如果数组中的所有元素都大于key，则为错误情况。

—>如果数组中的所有元素都等于且<=键，则最糟糕的情况是输入到我们的实现中。

这是实现，

// largest value <= key
// Invariant: A[l] <= key and A[r] > key
// Boundary: |r - l| = 1
// Input: A[l .... r-1]
// Precondition: A[l] <= key <= A[r]
int Floor(int A[], int l, int r, int key)
{
    int m;
  
    while( r - l > 1 )
    {
        m = l + (r - l)/2;
  
        if( A[m] <= key )
            l = m;
        else
            r = m;
    }
  
    return A[l];
}
  
// Initial call
int Floor(int A[], int size, int key)
{
    // Add error checking if key < A[0]
    if( key < A[0] )
        return -1;
  
    // Observe boundaries
    return Floor(A, 0, size, key);
}

您可以在http://ideone.com/z0Kx4a上看到一些测试用例。

问题陈述：给定排序数组，其中可能包含重复的元素。在N次日志中查找输入“键”的出现次数。

这里的想法是使用二进制搜索查找数组中最左键和最右键的出现。我们可以修改发言权函数以跟踪最右边的事件和最左边的事件。这是实现，

// Input: Indices Range [l ... r)
// Invariant: A[l] <= key and A[r] > key
int GetRightPosition(int A[], int l, int r, int key)
{
    int m;
  
    while( r - l > 1 )
    {
        m = l + (r - l)/2;
  
        if( A[m] <= key )
            l = m;
        else
            r = m;
    }
  
    return l;
}
  
// Input: Indices Range (l ... r]
// Invariant: A[r] >= key and A[l] > key
int GetLeftPosition(int A[], int l, int r, int key)
{
    int m;
  
    while( r - l > 1 )
    {
        m = l + (r - l)/2;
  
        if( A[m] >= key )
            r = m;
        else
            l = m;
    }
  
    return r;
}
  
int CountOccurances(int A[], int size, int key)
{
    // Observe boundary conditions
    int left = GetLeftPosition(A, -1, size-1, key);
    int right = GetRightPosition(A, 0, size, key);
  
    // What if the element doesn't exists in the array?
    // The checks helps to trace that element exists
    return (A[left] == key && key == A[right])?
           (right - left + 1) : 0;
}

示例代码http://ideone.com/zn6R6a。

问题陈述：给定一个由不同元素组成的排序数组，并且该数组在未知位置旋转。在数组中查找最小元素。

我们可以在下图中看到示例输入数组的图形表示。

我们收敛搜索空间，直到l和r指向单个元素。如果中间位置落在第一个脉冲中，则条件A [m]

下面给出的是算法的实现。您能提出不同的实现方式吗?

int BinarySearchIndexOfMinimumRotatedArray(int A[], int l, int r)
{
    // extreme condition, size zero or size two
    int m;
  
    // Precondition: A[l] > A[r]
    if( A[l] <= A[r] )
        return l;
  
    while( l <= r )
    {
        // Termination condition (l will eventually falls on r, and r always
        // point minimum possible value)
        if( l == r )
            return l;
  
        m = l + (r-l)/2; // 'm' can fall in first pulse,
                        // second pulse or exactly in the middle
  
        if( A[m] < A[r] )
            // min can't be in the range
            // (m < i <= r), we can exclude A[m+1 ... r]
            r = m;
        else
            // min must be in the range (m < i <= r),
            // we must search in A[m+1 ... r]
            l = m+1;
    }
  
    return -1;
}
  
int BinarySearchIndexOfMinimumRotatedArray(int A[], int size)
{
    return BinarySearchIndexOfMinimumRotatedArray(A, 0, size-1);
}

请参阅示例测试案例http://ideone.com/KbwDrk。

练习：

1.一种函数称为正负号(X，Y)被定义为，

signum(x, y) = -1 if x < y
             =  0 if x = y
             =  1 if x > y

您是否遇到过任何比较符号行为类似于指令集函数的指令集?可以使二进制搜索的第一个实现最佳化吗?

2.实现地板函数的ceil函数复制品。

3.与您的朋友讨论“二元搜索是否最佳(比较结果最少)?为什么不对排序数组进行三元搜索或内插搜索?您何时会选择三元搜索或插值搜索而不是二进制搜索?”

4.画一个二进制搜索的树形表示(相信我，它对您理解二进制搜索的许多内部知识有很大帮助)。

请继续关注，在接下来的文章中，我将使用二进制搜索介绍更多有趣的问题。我欢迎您的评论。