原创整理,转载请注明出处。
这是一个经常遇到的经典问题,这里分两个部分讲解和总结,首先对讲解现有的算法,然后再讲解一些 改进 算法。
1.循环法(Iterated Count )
最容易理解和想到的方法。对每一位依次判断是否为1,如果是就在count上加1。 循环的次数是常数(n的位数)。在1比较稀疏的时候效率低,可用方法2改进。
2.Bit1稀疏Sparse Ones
理解这个算法的核心,只需理解2个操作: 1> 当一个数被减1时,他最右边的那个值为1的Bit将变为0,同时其右边的所有的Bit都会变成1。
2>“&= ”,位与并赋值操作。去掉已经被计数过的1,并将改值重新设置给n. 这个算法循环的次数是bit位为一的个数。也就说有几个Bit为1,循环几次。对Bit为1比较稀疏的数来说,性能很好。如:0x1000 0000, 循环一次就可以。
3.密集1的算法 Dense Ones
与2稀疏1的算法相类似。不同点是,针对1密集的情况,循环的次数会大大减少。他的循环次数:sizeof(int)-Bit 1的个数。
4.8bit静态表查找法 Precompute_8bit
使用静态数组表,列出所有8bit(256个)无符号数含有Bit1的个数。将32Bit 的n分4部分,直接在表中找到对应的Bit1的个数,然后求和。
这是最快的方法了。缺点是需要比较大的内存。
5.16bit静态表查找法Precompute_16bit
因为在计算64位int时,以上方法4并不总是最快,所以有以下的一个进化版,就是用十六Bit的表来作驱动映射。这样需要的内存就更大了。
6. 合并计数器法 Parallel Counter
这个算法是一种合并计数器的策略。把输入数的32Bit当作32个计数器,代表每一位的1个数。然后合并相邻的2个“计数器”,使i成为16个计数器,每个计数器的值就是这2个Bit的1的个数;继续合并相邻的2个“计数器“,使i成为8个计数器,每个计数器的值就是4个Bit的1的个数。。依次类推,直到将i变成一个计数器,那么它的值就是32Bit的i中值为1的Bit的个数。
举个例子,假设输入的i值为10010111011111010101101110101111(十进制2541575087)
计算过程如下:(共22个1)
1. 将 32 个计数器合并为 16 个 , 每一个计数器代表 2-bit 的 1 个数
1001011000111111 = 1001011000111111
+ 0111111111010011 = 0111111111010011
----------------------------------------------------------------------
1112122111121122 = 01010110011010010101011001011010
2. 将 16 个计数器合并为 8 个 , 每一个计数器代表 4-bit 的 1 个数
11121112 = 0101011001010110
+ 12211212 = 0110100101100110
-----------------------------------------------------
23332324 = 0010 0011 0011 0011 0010 0011 0010 0100
3. 将 8 个计数器合并为 4 个 , 每一个计数器代表 8-bit 的 1 个数
3334 = 0010 0011 0010 0010
+ 2322 = 0011 0011 0011 0100
------- -----------------------------------
5656 = 00000101 00000110 00000101 00000110
4. 将 4 个计数器合并为 2 个 , 每一个计数器代表 16-bit 的 1 个数
5 5 = 00000101 00000101 + 6 6 = 00000110 00000110
--------------------------------------
11 11 = 0000000000001011 0000000000001011
5. 最后,将 2 个计数器合并为 1 个 , 每一个计数器代表 32-bit (也就是输入的值 i )的 1 个数
11 = 0000000000001011
+11 = 0000000000001011
----------------------------------
22 = 00000000000000000000000000010110
对于该算法的实现,另外有一种比较好的写法,这种算法避免了使用常数宏,使比较通用的实现:
7. 合并计数器法的优化
优化1:
算法的优化:基于以下两点合并计数器法可以进行优化:
1) 和的存储空间为 log2 (the number of bits being counted )*(coutern number).随着(coutern number)减少,需要的存储bit减少。但是实际每次都被存储在一个32位整数。
2) 在多数架构中,简单的8-bit的常量比32-bit的更容易构造。
基于以上2点,最后的一步:
i = (i&MASK16) + (i>>16&MASK16)
可以变成:
i = (i + (i>>16))&MASK6;
MASK6是(1<<6)-1 or 0x1F,可以消除需要进行MASK16的操作。 经过这样的优化,可以节省两个操作:建立各大整数常量 和 一个与(AND)操作
举个例子,假设输入的i值为10010111011111010101101110101111(十进制2541575087)
计算过程如下:(共22个1)
1. 将32个计数器合并为16个, 每一个计数器代表2-bit的1个数
1 0 0 1 0 1 1 0 0 0 1 1 1 1 1 1 = 1 0 0 1 0 1 1 0 0 0 1 1 1 1 1 1
+0 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 = 0 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1
----------------------------------------------------------------------
1 1 1 2 1 2 2 1 1 1 1 2 1 1 2 2 = 01 01 01 10 01 10 10 01 01 01 01 10 01 01 10 10
2. 将16个计数器合并为8个, 每一个计数器代表 4-bit 的1个数
1 1 1 2 1 1 1 2 = 01 01 01 10 01 01 01 1
+1 2 2 1 1 2 1 2 = 01 10 10 01 01 10 01 10
-----------------------------------------------------
2 3 3 3 2 3 2 4 = 0010 0011 0011 0011 0010 0011 0010 0100
3. 将8个计数器合并为4个,每一个计数器代表 8-bit 的1个数:y = (x + (x >> 4) & MASK4)
0010 0011 0011 0011 0010 0011 0010 0100
+
0000 0010 0011 0011 0011 0010 0011 0010
------- ---------------------------------------------------
0010 0101 0110 0110 0101 0101 0101 0110
&MASK4
0000 1111 0000 1111 0000 1111 0000 1111
------- --------------------------------------------------
0000 0101 0000 0110 0000 0101 0000 0110
计算相邻的每对(只有2对,即4个Counter)8bit计数器的和(不进行合并计数器的操作)。
0000 0101 0000 0110 0000 0101 0000 0110
+
0000 0000 0000 0101 0000 0110 0000 0101
--------------------------------------
0000 0101 0000 1011 0000 1011 0000 1011
5. 计算最后一对Counter(16BitCounter)的和,并根据掩码求出世纪的有效数字。其实将4,5步的与掩码运算合并为只进行一次。
0000 0101 0000 1011 0000 1011 0000 1011
0000 0000 0000 0000 0000 0101 0000 1011
----------------------------------
0000 0101 0000 1011 0001 0000 0001 0110
&MASK6
0000 0000 0000 0000 0000 0000 0011 1111
----------------------------------
0000 0000 0000 0000 0000 0000 0001 0110 = 22
优化2:
然而以上的算法,仍然可以优化为:这也许是最好的算法了。
与优化1比较,又进行了以下两点优化:
1) 为了在第一行不使用AND操作,替换相邻位相加的操作为:v减去它的右移操作后与掩码操作的结果。这个结果以相同的。00 - 0 = 0, 01 - 0 = 01, 10 - 1 = 01, 11 - 1 = 1
即:v= (v&MASK1 ) + (v>>1 &MASK1 );
w = v - ((v >> 1) & MASK1);
v=w
2) 为了合并最后两行,使用了一个乘法运算(00000001 00000001 00000001 00000001)和一个位移操作(只取最右边6位),这样的处理在一步就累加了4Bit大小的计数器。可以回忆乘法运算的竖式计算法,就是对第三步的结果Y,分为每8bit大小的四组,然后求和。
优化3:
还可以进行如下的优化:
请根据除法的意义思考为什么取255的余数。
8 MIT_HACKEMEM 计数法 MIT HACKMEM Count
这是一种很巧妙的算法:
考虑一个3Bit数N,可以看成4a+2b+c (a,b,c为0 或者1),如果右移一位,得到2a+b,然后从原始的数(4a+2b+c)里减去2a+b,(N-N>>1)差为2a+b+c。如果右移两位,得到a,然后用刚才得到的差2a+b+c减去a,(即(N-N>>1-N>>2)结果是a+b+c,这就是原始的数字里Bit为1的个数。
这个算法如何实现呢?首先声明一个临时变量tmp 。认为tmp 是8进制描述的。8进制的每个数字都是n中相应的每3Bit位所描述的数字。最后返回这些8进制数的和就是我们需要的最终答案了。关键是,将相邻的8进制对加在一起,然后计算时记得对63(2的(3+3)次幂)-1)进行除运算取得余数。实现方法是:使用tmp 右移3位、然后与自身相加,再与一个适当的掩码进行AND操作,产生一个数,这个数是相邻6位中含有Bit1的个数。
对 64位数来说,应该比8进制数的多3倍(4倍),所以要对1023(64*(2的4次幂)-1)求模。(这算法在X11代码中被用到过。)