如何在 O(1) 时间内找到二进制数中 1 的个数？答案

【问题标题】：How to find number of 1's in a binary number in O(1) time?如何在 O(1) 时间内找到二进制数中 1 的个数？
【发布时间】：2013-11-01 15:05:41
【问题描述】：

我知道以前有人问过这个问题，但我正在查看here 列出的这个特定解决方案：

int BitCount(unsigned int u)
{
     unsigned int uCount;

     uCount = u - ((u >> 1) & 033333333333) - ((u >> 2) & 011111111111);
     return ((uCount + (uCount >> 3)) & 030707070707) % 63;
}

它是如何工作的？

这里有什么注意事项吗？

理论上是否有可能在恒定时间内找到答案？我的意思是我们实际上不是有遍历位来计数吗？

【问题讨论】：

除非您处理的是多精度数字，否则遍历位是常数时间 --- 常数是整数位的大小。
从技术上讲，一个无符号整数是 4 个字节，如果你总是迭代 int 中的所有 32 位而不考虑 N，那么 从技术上讲它是 O(1)。请记住，O(1) 意味着时间复杂度不会随着 N 的值而变化。
需要注意的是，这只适用于 32 位输入（无符号整数）。因此，输入是已知的并且具有恒定长度，因此一些花哨的位算术可以给出答案。如果它是一个非恒定长度，那么迭代几乎是不可避免的。
请注意，如果 N 没有上限，那么算法必须是 O(log N)。
虽然这是一个有趣且可能具有启发性的解决方案，但非 2 的幂的模通常使其比几个替代方案慢，例如 this one 或几个表查找（通常使用一个 256 个条目的表）。

标签： c algorithm bit-manipulation

【解决方案1】：

计数位

一个无符号的 32 位整数 u 可以这样写：

u = a31 * 231 + a30 * 230 + ... + a0 * 20

我们想要a31 + a30 + ... + a0 的值。

我们比较一下u >> k的值：

u >> 0 = a₃₁ * 2³¹ + a₃₀ * 2³⁰ + ... + a ₁ * 2¹ + a₀ * 2⁰ u >> 1 = a₃₁ * 2³⁰ + a₃₀ * 2²⁹ + ... + a ₁ * 2⁰ u >> 2 = a₃₁ * 2²⁹ + a₃₀ * 2²⁸ + ... ... u >> 29 = a₃₁ * 2² + a₂₉ * 2¹ + ... u >> 30 = a₃₁ * 2¹ + a₃₀ * 2⁰ u >> 31 = a₃₁ * 2⁰

我们将通过这个公式计算比特人口：

u >> 0 - u >> 1 - u >> 2 - ... - u >> 31 = p

让我们看看为什么会这样：

  u >> 0 - u >> 1 - u >> 2 - ... - u >> 31
= u >> 0 - (u >> 1 + u >> 2 + ... + u >> 31)
= u - q

q 的值是多少？让我们一点一点地计算它，看看上面u >> k 的值。对于a31，它是：

a₃₁ * 2³⁰ + a₃₁ * 2²⁹ + ... = a₃₁ * (2³⁰ + 2²⁹ + ...) = a₃₁ * (2³¹ - 1)

或者a30：

a₃₀ * 2²⁹ + a₃₀ * 2²⁸ + ... = a₃₀ * (2²⁹ + 2²⁸ + ...) = a₃₀ * (2³⁰ - 1)

我们发现：q = a31 * (231 - 1) + a30 * (230 - 1) + ...

因此

u - q = a₃₁ * 2³¹ - a₃₁ * (2³¹ - 1) + .. . = a₃₁ + a₃₀ + ... + a₀

计算 3 位块中的位数

这个算法开始做同样的事情，但在 3 位块中：

u >> 0                = AaBbbCccDddEeeFffGggHhhIiiJjjKkk (each letter is a bit)
u >> 1 & 033333333333 =  A Bb Cc Dd Ee Ff Gg Hh Ii Jj Kk (blank = zero)
u >> 2 & 011111111111 =     B  C  D  E  F  G  H  I  J  K

通过上述算法，uCount中的每个八位字节包含u中相应八位字节中设置的位数。

uCount      =   αβγδεζηθικλ (each greek letter is an octet)
uCount >> 3 =    αβγδεζηθικ

所以uCount + (uCount >> 3) 是(λ+κ) * 20 + (κ+ι) * 23 + (ι+θ) * 26 + ...

通过与0o30707070707 进行与运算，我们屏蔽了所有其他八位字节，因此我们只对每一对计数一次：

r = (λ+κ) * 2⁰ + (ι+θ) * 2⁶ + (η+ζ) * 2^{12支持> + ...
  = (λ+κ) * 64⁰ + (ι+θ) * 64¹ + (η+ζ) * 64² + 。 ..}

这是一个 base-64 数字，我们想将 base-64 数字相加得到 α+β+γ+δ+ε+ζ+η+θ+ι+κ+λ，我们的最终结果。为此，我们计算它的 base-64 digital root：知道结果永远不会大于 32，我们只需将数字取模 63。

【讨论】：

【解决方案2】：

迭代位是恒定时间，因为类型中的位数是恒定的。

因此，检查一位掩码并针对目标值中的每一位进行移位的解决方案确实是O(1)（例如，常量为 32）。

【讨论】：

我没有投反对票，您的回答是正确的，但我认为他的意思是高效时间而不是 O(1) 复杂性。这个问题确实措辞不好，但似乎他只是想了解如何在没有循环的情况下完成。
我会说 O(1) 时间意味着排除循环通过位数（即 O(n) 时间）的解决方案，包括低级别的此类解决方案或例程，所以我会采取它是只使用二进制算术的解决方案作为一个整体并且不是每个位的每个位。顺便说一句，我想问完全相同的问题，但要找到（最重要的）设置位的位置（即binary logarithm in O(1)）

【解决方案3】：

最快的方法是 popcnt 指令。您通常可以通过compiler intrinsic 访问它。您的解决方案在缺少此说明的平台上可能很有用。

【讨论】：

【解决方案4】：

Counting bits set, in parallel 显示了这是如何完成的。该方法可用于 8 位、16 位、32 位、64 位、128 位等位字，尽管计算中使用的常数会发生变化。

当我们说这个操作是 O(1) 时，我们的意思是它可以在恒定时间内完成 不管字长。 简单的计算位数是 O(n) in位数。

实际上，当处理器可以原生处理字长时，这只是 O(1)。

至于它的工作原理，它使用了“幻数”。有关说明，请参阅 this newsgroup post。

【讨论】：

反对者，有什么要分享的吗？通常会提供反对的理由。