在C中严格执行下限

Question

我想出了这个解决方案来在排序数组中严格实现下限：

long lowerBound(long key, long size, long *a){
    long low = 0, high = size, mid;
    if(a[low] >= key){
        return -1;
    }
    while(low < high){
        mid = (low+high)/2;
        if(a[mid] >= key){
            high = mid - 1;
        } else{
            low = mid;
        }
    }
    return low;
}

但这似乎不起作用。 在某些测试案例中，它失败了。 例如：

A [7] = {0，1，1，3，5，5，10}

键= 4

它进入无限循环。

这是测试运行：

第一次迭代后：低= 3，高= 7，中= 3

第二次迭代后：低= 3，高= 4，中= 5

第三次迭代后：低= 3，高= 4，中=3。然后卡住了。

谁能指出我正确的方向。 提前致谢！！

Answer 1

之所以变得“卡住”，是因为当您的low等于high - 1 ， mid变为low ： (low+low+1)/2 == low ，那么a[mid] >= key为false并且mid再次设置为low 。 如果a[mid] < key ，则需要设置low到mid + 1 ，否则设置high到mid 。 . 然后，您将找到 。

UPD：而且，由于它是二进制搜索，您将始终得到low == high - 1 。 下次请记住！

UPD2：还有一件事！ 最好使用mid = low+((high-low)/2) ，因为这样可以防止某些溢出错误。

Answer 2

举个例子：

low = 3
high = 4

那么您的代码将做什么？

while(low < high){         // True as 3 is less than 4
    mid = (low+high)/2;    // (3+4)/2 --> mid = 3
    if(a[mid] >= key){     // a[3] is 3. And 3 isn't greater or equal 4 so this is false
        high = mid - 1;
    } else{                // So you take the else part

        low = mid;         // low is assigned 3. So you are back
                           // where you started and have an endless loop
    }

您需要确保分配给low和high不只是分配他们已经拥有的值。

例如：

else {
    if (low == mid) return low;
    low = mid;
}

Answer 3

如果数组的每个元素都是唯一的，则可以使用以下命令：

long binsearch(long *a, long size, long key) {
    long lo = 0;
    long hi = size-1;

    if (hi == -1)
       return -1;

    while (1) {
       long mid = ( lo + hi ) / 2;
       if (a[mid] == key)
          return mid;

       if (a[mid] < key) {
          hi = mid - 1;
          if (lo > hi)
             return ~mid;
       } else {
          lo = mid + 1;
          if (lo > hi)
             return ~lo;
       }
    }
}

但是您的数组可以有重复项，并且您想找到第一个，因此我们需要调整什么才是匹配项。

long binsearch_first(long *a, long size, long key) {
    long lo = 0;
    long hi = size-1;

    if (hi == -1)
       return -1;

    while (1) {
       long mid = ( lo + hi ) / 2;
       if (a[mid] == key && ( mid == 0 || a[mid-1] != key ))
          return mid;

       if (a[mid] <= key) {
          hi = mid - 1;
          if (lo > hi)
             return ~mid;
       } else {
          lo = mid + 1;
          if (lo > hi)
             return ~lo;
       }
    }
}

您可能已经注意到了特殊的返回值。 它的优点是可以返回没有找到key 。 这告诉您要将key添加到阵列中的位置。

long i = binsearch_first(a, a_size, key);
if (i >= 0) {
   printf("The first %ld was found at index %ld.\n", $key, i);
} else {
   printf("%ld wasn't found. It would have been found at index %ld.", $key, ~i);
}

Answer 4

您从high = size开始，因此上限超出范围，应该保持这种方式，也就是说，它永远不是解决方案。

因此出现两个错误：结束条件和新的high值的设置。

最终条件应为

while (high - low > 1)

之后，解决方案将low 。 并且新的high值的设置应为

if(a[mid] > key){               // change from >=
    high = mid;                 // mid is not valid
}