整数的二进制表示中的零数[重复]

Question

可能重复：
Best algorithm to count the number of set bits in a 32-bit integer?

给定一个 32 位整数 N，设计一个算法来找出 N 的二进制位表示中的零的个数。

我能想到的最简单的算法是检查零的二进制表示，在 C 中是这样的：

int num_of_zero(int num)
 {
   if(0 == num) return 1; /*For the input 0 it should output 1 */
   int Count = 0;
   while(num>0){
     if(0 == (num&1)) Count++;
    num >>= 1;
}
return Count;
}

如果有一些算法可以在恒定时间计算，我正在徘徊。

对于输入 0，它应该返回 1 而不是 32。

对于5，输出应该是1。因为二进制表示是101。

对于 7，输出应为 0。

确切地说，我正在寻找一种更好的算法来计算 32 位整数的二进制解释中（非前导）零的数量。希望问题现在很清楚。

编辑：正如 Alex Martelli 指出的那样，delroth 我正在修改我的代码以使其更具可读性并这次使用迭代。

Answer 1

执行此操作的简单方法是遍历数字的二进制表示的每一位，测试每一位的值，并计算其中有多少为零。循环会比递归更清晰。

不过，还有许多更优化的方法可以做到这一点。您可以在"Best algorithm to count the number of set bits in a 32-bit integer" 这个问题的答案中找到一些更好的答案（显然，零位数是从总位数中减去设置位数）。

Answer 2

有一个很棒的在线资源Bit Twiddling Hacks，其中包含各种很棒的 C 小技巧。您可能对Counting bits set 部分特别感兴趣。

Answer 3

快速而愚蠢的方式——在重复的问题中有更多奇特的实现，但我过去曾使用过类似的东西而没有太大的不良影响。

我们在这里使用一个半字节表来减少循环运行的次数——如果你正在做大量的这些计算，那么构建一个更大的数组可能会更有效，比如说，在字节水平，将循环切成两半。

/* How many bits are set in every possible nibble. */
static size_t BIT_TABLE[] = {
    0, 1, 1, 2,     /* 0, 1, 2, 3 */
    1, 2, 2, 3,     /* 4, 5, 6, 7 */
    1, 2, 2, 3,     /* 8, 9, A, B */
    2, 3, 3, 4      /* C, D, E, F */
};

size_t num_of_bits(int num) {
    /* Little reworking could probably shrink the stack space in use here. */
    size_t ret = 0, i;
    register int work = num;

    /* Iterate every nibble, rotating the integer in place. */
    for(i = 0; i < (sizeof(num) * 2); i++) {
        /* Pointer math to get a member of the static array. */
        ret += *(BIT_TABLE + (work & 0xF));
        work >>= 4;
    }
    return ret;
}

Answer 4

递归绝对是矫枉过正——此外，您的代码有很多错误（它不会计算num 的任何前导零！！！）。一个简单的迭代，如：

int num_of_zero(int num) {
  unsigned int unum = (unsigned int)num;
  int count;
  int i;

  for(i = 0; i < 32; ++i) {
    if(!(unum & 1)) ++count;
    unum >>= 1;
  }
  return count;
}

正确且速度更快（可以编码更简洁，但我认为这是最清晰的表达方式）。

如果您必须多次执行此计算，请考虑预先计算一个（例如）256 个“零计数”的数组（每个值给出其索引的计数，包括 0 到 255，作为 8 位数字）。然后，您可以只循环 4 次（一次屏蔽和移动 8 位），并轻松展开循环 - 如果您的编译器不够聪明，无法代表您执行此操作；-)。

Answer 5

我猜这是一道作业题。没问题！这是最快的解决方案（经过长时间的启动成本）：

创建一个长度为 2³² 的 byte 数组。为每个可能的int 值预先计算二进制表示中的零数的值以填充该数组。从那时起，您将拥有一个数组，该数组将为您提供每个值的零数。

是的，这个解决方案很愚蠢——做很多工作却收效甚微——但是将它与另一个想法结合起来：

如果您只预先计算 8 位长的值会发生什么？您能否编写代码，尽管速度不快，但仍会返回 int 中 0 的位数？

如果您只预先计算 4 位长的值会发生什么？ 2位长？ 1 位长？

我希望这能给您提供更好算法的想法...

Answer 6

这并不是你主要问题的真正答案，但你应该像这样重写你的递归函数：

int num_of_zero(int num)
{
    int left_part_zeros;

    if (num == 0)
        return 0;

    left_part_zeros = num_of_zero(num >> 1);
    if ((num & 1) == 0)
        return left_part_zeros + 1;
    else
        return left_part_zeros;
}

除了完全不可读之外，您的实现还有很多问题。

Answer 7

我发现的最简单的方法是将它建立在计算个数的基础上，然后简单地从 32 中减去它（假设您确定int 的大小是 32 位）。

int numberOfOnes (int num) {
    int count = 0;
    unsigned int u = (unsigned int)num;
    while (u != 0) {
        if ((u&1) == 1)
            count++;
        u >>= 1;
    }
    return count;
}
int numberOfZeros (int num) {
    return 32 - numberOfOnes (num);
}

这实际上为您提供了两种变体（一和零） - 有更快的方法可以做到这一点，但我不会考虑它们，除非并且直到您知道存在性能问题。我倾向于首先编写可读性代码。

您可能还想至少测试一下查找表可能更快的可能性（优化的主要指令是衡量，不要猜测！

一种可能是用一次操作一个 nybble 的东西替换 numberOfOnes 函数：

int numberOfOnes (int num) {
    static const count[] = {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
    };
    int retval = 0;
    unsigned int u = (unsigned int)num;
    while (u != 0) {
        retval += count[u & 0x0f]
        u >>= 4;
    }
    return retval;
}