在 O(log2(amount_bits)) 中使用二进制搜索查找 floor(log2(int)) 时遇到问题

Question

在我们的算法课上，教授在实验课上多了一道题。在 log2(n) 步中找到 n 位 int 的 floor(log2(x))（例如，当 T = uint64_t 时，n = 64）。

我们发现我们应该能够通过二分搜索来解决这个问题，但是在某些边缘情况下我们会得到一个关闭 1 的结果或无限循环。我们摸索了一段时间，但似乎无法做到这一点。我们如何最好地处理这个问题？我们试图用here 讨论的不变技巧来推理，但它似乎比它复杂一点。例如。对于十进制数，在第 7 位或第 6 位之间进行选择很困难，因为 128 大于 100，但 64 更小。不幸的是，在缓解这个问题时，我们打破了一些极端情况。

编辑：如下所述，这纯粹是一个学术问题，在现实生活中几乎没有可用性。

到目前为止，这是我们的代码：

//
//   h      l
//   76543210
// 0b01000001 = 65
//

using T = unsigned char;

int lgfloor(T value)
{
    assert(value > 0);

    int high = ((sizeof(value) * 8) - 1);
    int low = 0;
    int mid = 0;
    T guess = 0;

    while (high > low)
    {
        mid = (low + ((high - low) / 2));
        guess = static_cast<T>(1) << mid;

        printf("high: %d, mid: %d, low: %d\n", high, mid, low);

        if (value < guess)
        {
            high = mid - 1;
        }
        else
        {
            low = mid;
        }
    }

    return low;
}

我们创建了以下单元测试（使用 GoogleTest）：

TEST(LgFloor, lgfloor)
{
    ASSERT_DEATH(lgfloor(-1), "Assertion `value > 0' failed.");
    ASSERT_DEATH(lgfloor(0), "Assertion `value > 0' failed.");

    ASSERT_EQ(lgfloor(1), 0);
    ASSERT_EQ(lgfloor(2), 1);
    ASSERT_EQ(lgfloor(64), 6);
    ASSERT_EQ(lgfloor(100), 6);
}

提前致谢， 亲切的问候，

貂

Answer 1

您需要一个适当的退出条件。假设y = floor(lg2(x))。当2^low <= x 和x < 2^(low+1) 时，您应该退出循环。但是如果high == low+1 则满足，但您当前没有退出。做吧：

while (high > low+1)
{

看看你的循环中的不变量是很好的。例如，我们可以尝试维护x < 2^high（这需要从sizeof(T)*8 开始，而不是sizeof(T)*8 - 1）。然后你需要做的就是平分直到low == high-1，你就完成了。

如果x < 2^mid，即如果value < guess，我们可以通过仅将high 更改为mid 来保持这个不变量。这是第一种情况：

if (value < guess)
  high = mid;

我们还必须维护2^low <= x = value。所以，在 else 分支中（需要2^mid == guess < value，我们可以安全地设置low = mid。

else
  low = mid;

剩下的就是证明循环总是在进行。由于high > low+1，我们有high - low >= 2，因此有mid != low 和mid != high。显然，我们正在将每次迭代的时间间隔（减半）。

所以你去：

int lgfloor(T value)
{
    assert(value > 0);

    int high = (sizeof(value) * 8);
    int low = 0;

    while (high > low+1)
    {
        int mid = (low + ((high - low) / 2));
        T guess = static_cast<T>(1) << mid;

        printf("high: %d, mid: %d, low: %d\n", high, mid, low);

        if (value < guess)
            high = mid;
        else
            low = mid;
    }

    return low;
}

---

我当然应该注意，在现代硬件中，有专门用于此目的的内部函数。例如，在 Intel's intrinsics guide 中搜索 _BitScanReverse，这将在上述代码所需周期的一小部分内完成。

在处理固定宽度类型（例如 C++ 的整数类型）时，依赖于位宽的渐近运行时无论如何都是毫无意义的（尽管这个问题仍然具有教育价值）。

Answer 2

无限循环是由于这一行：

 mid = (low + ((high - low) / 2));

如果high 和low 相差1，则结果可能是mid == low，然后在while 循环中导致low = mid 的条件下，您将永远检查相同的条件。我的建议是，如果你在循环中有low = mid，那么在这种情况下你必须确保你的mid != low。因此，只需在分配之前检查此内容，如果发生这种情况，请执行 low = mid+1。

Answer 3

解决方案必须在lg(n) 步骤中找到，这意味着诸如low= 0、high= 32 之类的初始化将不起作用，因为它在每种情况下都需要5 步骤并且不适用于x 大于 2^32。正确的解决方案必须结合第一个 geometric 搜索，其中您将指数加倍，然后是标准二分搜索。

# Geometric search
low= 0
high= 1
while (1 << high) <= x:
    low= high
    high+= high

# Dichotomic search
while high - low > 1:
    mid= (high + low) >> 1
    if x < mid:
        high= mid
    else:
        low= mid

Answer 4

似乎您只需将 if 转移到正确的“日志”时间，直到您有一个“1”。

using T = unsigned char;

int lgfloor(T value)
{
  assert(value > 0);

  int log = 0;
  while(value != 1) {
    value >> 1;
    log++;
  }
  return log;
}